/* sava_data bin (C->S) */ EdpPacket* PacketSavedataBin(const char* dst_devid, cJSON* desc_obj, uint8* bin_data, uint32 bin_len) { EdpPacket* pkg; uint32 remainlen; /* check arguments */ char* desc_out = cJSON_Print(desc_obj); uint32 desc_len = mystrlen(desc_out); if (desc_len > (0x01 << 16) || bin_len > (3 * (0x01 << 20)) /* desc < 2^16 && bin_len < 3M*/ || cJSON_GetObjectItem(desc_obj, "ds_id") == 0) /* desc_obj MUST has ds_id */ { hx_free(desc_out); return 0; } pkg = NewBuffer(); /* msg type */ WriteByte(pkg, SAVEDATA); if (dst_devid) { /* remain len */ remainlen = 1+(2+mystrlen(dst_devid))+1+(2+desc_len)+(4+bin_len); WriteRemainlen(pkg, remainlen); /* translate address flag */ WriteByte(pkg, 0x80); /* dst devid */ WriteStr(pkg, dst_devid); } else { /* remain len */ remainlen = 1+1+(2+desc_len)+(4+bin_len); WriteRemainlen(pkg, remainlen); /* translate address flag */ WriteByte(pkg, 0x00); } /* bin flag */ WriteByte(pkg, 0x02); /* desc */ WriteStr(pkg, desc_out); hx_free(desc_out); /* bin data */ WriteUint32(pkg, bin_len); WriteBytes(pkg, bin_data, bin_len); return pkg; }
main() { bufferADT buffer; buffer = NewBuffer(); while (TRUE) { printf("*"); ExecuteCommand(buffer, GetLine()); DisplayBuffer(buffer); } FreeBuffer(buffer); }
JNIEXPORT jobject JNICALL Java_at_o2xfs_xfs_cdm_v3_100_Denominate3Test_buildDenominate3(JNIEnv *env, jobject object) { Denominate.usTellerID = 0; Denominate.usMixNumber = WFS_CDM_INDIVIDUAL; Denominate.lpDenomination = &Denomination; strcpy(Denomination.cCurrencyID, "EUR"); Denomination.ulAmount = 1234; Denomination.usCount = 3; Denomination.lpulValues = Values; Denomination.ulCashBox = 456; return NewBuffer(env, &Denominate, sizeof(WFSCDMDENOMINATE)); }
LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { if(msg > WM_USER) { g_pEnv->CallVoidMethod(handlerObj, callbackMID, msg, NewBuffer(g_pEnv, &lParam, sizeof(lParam))); return 0; } else { switch(msg) { case WM_DESTROY: PostQuitMessage(0); return 0; } } return DefWindowProc(hWnd, msg, wParam, lParam); }
JNIEXPORT jobject JNICALL Java_at_o2xfs_xfs_cam_v320_CamStructV3_120Test_createCamStatusV3_120(JNIEnv *env, jobject obj) { status.fwDevice = WFS_CAM_DEVONLINE; for(int i = 0; i < WFS_CAM_CAMERAS_SIZE; i++) { status.fwMedia[i] = WFS_CAM_MEDIANOTSUPP; status.fwCameras[i] = WFS_CAM_CAMNOTSUPP; status.usPictures[i] = 0; } status.fwMedia[WFS_CAM_PERSON] = WFS_CAM_MEDIAOK; status.fwCameras[WFS_CAM_PERSON] = WFS_CAM_CAMOK; status.usPictures[WFS_CAM_PERSON] = 1; status.wAntiFraudModule = WFS_CAM_AFMOK; status.lpszExtra = lpszExtra; return NewBuffer(env, &status, sizeof(WFSCAMSTATUS)); }
BOOL CCircuitry::OnRingPacket(CRingPacket* pPacket) { int nChan = pPacket->GetLineId(); SsmSetRecMixer( nChan, FALSE, 0 ); SsmSetDTMFStopRecCharSet( nChan, "" ); SsmSetDtmfStopPlay( nChan, FALSE ); NewBuffer( nChan ); Start( nChan, TRUE ); return SendPacket( pPacket, TRUE ); }
/* Allocate alot of garbage */ static void PR_CALLBACK AllocStuff(void *unused) { PRInt32 i; void* danglingRefs[50]; PRIntervalTime start, end; char msg[100]; start = PR_IntervalNow(); for (i = 0; i < loops; i++) { void* p; if (i & 1) { Type1* t1 = NewType1(); t1->atwo = NewType2(); t1->next = NewType1(); t1->atwo->buf = NewBuffer(100); p = t1; } else { Type2* t2 = NewType2(); t2->buf = NewBuffer(i & 16383); p = t2; } if ((i % 10) == 0) { memmove(&danglingRefs[0], &danglingRefs[1], 49*sizeof(void*)); danglingRefs[49] = p; } } end = PR_IntervalNow(); if (debug_mode) PR_snprintf(msg, sizeof(msg), "Thread %p: %ld allocations took %ld ms", PR_GetCurrentThread(), loops, PR_IntervalToMilliseconds((PRIntervalTime) (end - start))); PR_Lock(stderrLock); #ifndef XP_MAC fprintf(stderr, "%s\n", msg); #else if (debug_mode) printf("%s\n", msg); #endif PR_Unlock(stderrLock); }
IFXString::IFXString(const IFXCHAR* operand) : m_Buffer(NULL), m_BufferLength(0) { if(!operand) { DeleteBuffer(); } else { NewBuffer((U32)wcslen(operand)+1); if (m_Buffer) wcscpy(m_Buffer, operand); } }
/* ping (C->S) */ EdpPacket* PacketPing(void) { EdpPacket* pkg = NewBuffer(); if(!pkg->_data) { PrintLine("NewBuffer error"); return NULL; } /* msg type */ WriteByte(pkg, PINGREQ); /* remain len */ WriteRemainlen(pkg, 0); return pkg; }
/* push_data (C->S) */ EdpPacket* PacketPushdata(const char* dst_devid, const char* data, uint32 data_len) { EdpPacket* pkg = NewBuffer(); uint32 remainlen; /* msg type */ WriteByte(pkg, PUSHDATA); /* remain len */ remainlen = (2+mystrlen(dst_devid))+data_len; WriteRemainlen(pkg, remainlen); /* dst devid */ WriteStr(pkg, dst_devid); /* data */ WriteBytes(pkg, data, data_len); return pkg; }
JNIEXPORT jobject JNICALL Java_at_o2xfs_xfs_cam_v320_CamStructV3_120Test_createCamCapsV3_120(JNIEnv *env, jobject obj) { caps.wClass = WFS_SERVICE_CLASS_CAM; caps.fwType = WFS_CAM_TYPE_CAM; for(int i = 0; i < WFS_CAM_CAMERAS_SIZE; i++) { caps.fwCameras[i] = WFS_CAM_NOT_AVAILABLE; } caps.fwCameras[WFS_CAM_ROOM] = WFS_CAM_AVAILABLE; caps.usMaxPictures = 100; caps.fwCamData = WFS_CAM_AUTOADD | WFS_CAM_MANADD; caps.usMaxDataLength = 64; caps.fwCharSupport = WFS_CAM_ASCII | WFS_CAM_UNICODE; caps.lpszExtra = lpszExtra; caps.bPictureFile = TRUE; caps.bAntiFraudModule = TRUE; return NewBuffer(env, &caps, sizeof(WFSCAMCAPS)); }
JNIEXPORT jobject JNICALL Java_at_o2xfs_xfs_cdm_v3_130_Blacklist3_130Test_buildBlacklist3_130(JNIEnv *env, jobject obj) { Blacklist.lpszVersion = Version; Blacklist.usCount = 2; Blacklist.lppBlacklistElements = lppBlacklistElements; BlacklistElements[0].lpszSerialNumber = SerialNumber[0]; strcpy(BlacklistElements[0].cCurrencyID, "EUR"); BlacklistElements[0].ulValue = 10; lppBlacklistElements[0] = &BlacklistElements[0]; BlacklistElements[1].lpszSerialNumber = SerialNumber[1]; strcpy(BlacklistElements[1].cCurrencyID, "EUR"); BlacklistElements[1].ulValue = 50; lppBlacklistElements[1] = &BlacklistElements[1]; return NewBuffer(env, &Blacklist, sizeof(WFSCDMBLACKLIST)); }
HRESULT CLR_RT_HeapBlock_MemoryStream::Initialize( CLR_UINT8* buf, CLR_UINT32 len ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); m_buffers.DblLinkedList_Initialize(); // CLR_RT_DblLinkedList m_buffers; // EVENT HEAP - NO RELOCATION - list of CLR_RT_HeapBlock_MemoryStream::Buffer CHECK_ALLOCATION(NewBuffer()); if(buf) { m_current->m_data = buf; m_current->m_length = len; } TINYCLR_NOCLEANUP(); }
IFXString::IFXString(const IFXString* operand) : m_Buffer(NULL), m_BufferLength(0) { if(!operand) { DeleteBuffer(); } else { if (operand->m_BufferLength > 0) { NewBuffer((U32)operand->m_BufferLength); if (m_Buffer) wcscpy(m_Buffer, operand->m_Buffer); } } }
/* recv stream to a edp packet (S->C) */ EdpPacket* GetEdpPacket(RecvBuffer* buf) { EdpPacket* pkg = NULL; int32_t flag = 0; flag = IsPkgComplete(buf); if (flag <= 0) { printf("%s flag<=0\n", __func__); return pkg; } pkg = NewBuffer(); WriteBytes(pkg, buf->_data, flag); /* shrink buffer */ memmove(buf->_data, buf->_data + flag, buf->_write_pos - flag); buf->_write_pos -= flag; return pkg; }
EdpPacket* PacketSavedataBinStr(const int8_t* dst_devid, const int8_t* desc_str, const uint8_t* bin_data, uint32_t bin_len) { EdpPacket* pkg = NULL; uint32_t remainlen = 0; uint32_t desc_len = 0; /* check arguments */ desc_len = strlen((const char *)desc_str); if (desc_len > (0x01 << 16) || bin_len > (3 * (0x01 << 20))) { /* desc < 2^16 && bin_len < 3M*/ return 0; } pkg = NewBuffer(); /* msg type */ WriteByte(pkg, SAVEDATA); if (dst_devid) { /* remain len */ remainlen = 1 + (2 + strlen((const char *)dst_devid)) + 1 + (2 + desc_len) + (4 + bin_len); WriteRemainlen(pkg, remainlen); /* translate address flag */ WriteByte(pkg, 0x80); /* dst devid */ WriteStr(pkg, dst_devid); } else { /* remain len */ remainlen = 1 + 1 + (2 + desc_len) + (4 + bin_len); WriteRemainlen(pkg, remainlen); /* translate address flag */ WriteByte(pkg, 0x00); } /* bin flag */ WriteByte(pkg, 0x02); /* desc */ WriteStr(pkg, desc_str); /* bin data */ WriteUint32(pkg, bin_len); WriteBytes(pkg, bin_data, bin_len); return pkg; }
static void PPDialingHandler(SignalType * Signal) { switch (Signal->Event) { case IWU_PRIMITIVE: { switch (Signal->SubEvent) { case CC_CONNECT_prim: { SignalType * startAudio; NewBuffer(sizeof(SignalType), (void**) &startAudio); SendSignal((SignalType*) startAudio, DSP_PROCESS_ID, SETUPAUDIO_EVENT, 0); connected = 1; } case CC_INFO_prim: /*do not break*/ { if (connected == 1) { SignalType* mySignal; NewSignal(sizeof(SignalType) + 2 + strlen(numberToDial), (void **) &mySignal); getSignalData(mySignal)[0] = 0x2c; getSignalData(mySignal)[1] = strlen(numberToDial); memcpy(getSignalData(mySignal) + 2, numberToDial, strlen(numberToDial)); InjectSignal(mySignal, IWU_PROCESS_ID, IWU_PRIMITIVE, CC_INFO_prim, Signal->SessionId); } } break; case CC_RELEASE_prim: { if (connected == 1) { Signal->SignalLength = sizeof(CcReleaseComPrimType); SendSignal(Signal, IWU_PROCESS_ID, IWU_PRIMITIVE, CC_RELEASE_COM_prim); connected = 0; setSignalHandler(APPLICATION_PROCESS_ID_PP, PPconnectionHandler, 0); return; } } break; } } } DeleteBuffer(Signal); }
ApplicationInstanceType * getApplicationInstance(PMIDType PMID) { ApplicationInstanceType *applicationInstanceData; applicationInstanceData = (ApplicationInstanceType *) GetNode(&applicationTree, PMID); if (applicationInstanceData == NULL) { NewBuffer(sizeof(ApplicationInstanceType), (void **) &applicationInstanceData); memcpy(applicationInstanceData->pmid, PMID, sizeof(PMIDType)); applicationInstanceData->state = idle; applicationInstanceData->msfState = msf_idle; applicationInstanceData->timer = 0; AddNode(&applicationTree, applicationInstanceData, applicationInstanceData->pmid); created++; PrintStatus(0, "created: "); } return applicationInstanceData; }
VOID Queue<T,ElementTraits,ThreadingModel>::Enqueue( CONST T& Item ) { if (m_Tail < m_Head) { if (m_Head < m_Buffer.Length()) m_Buffer[m_Head++] = Item; else { if (m_Tail > 0) m_Head = 0; else { if (m_Buffer.Length() < 16) m_Buffer.Resize( 16 ); else m_Buffer.Resize( (SIZE_T)((FLOAT)(m_Buffer.Length()+1) * 1.5) ); } m_Buffer[m_Head++] = Item; } } else if (m_Tail > m_Head) m_Buffer[m_Head++] = Item; else if (m_Tail == m_Head) { if (m_Tail == 0) { if (m_Buffer.Length() < 16) m_Buffer.Resize( 16 ); m_Buffer[m_Head++] = Item; } else { SIZE_T TailSize = m_Buffer.Length() - m_Tail; Buffer<T> NewBuffer( (SIZE_T)((FLOAT)(m_Buffer.Length()+1) * 1.5) ); CopyObjects( &NewBuffer[0] , &m_Buffer[m_Tail], TailSize ); CopyObjects( &NewBuffer[TailSize] , &m_Buffer[0], m_Head ); m_Tail = 0; m_Head = m_Buffer.Length(); m_Buffer = NewBuffer; m_Buffer[m_Head++] = Item; } } }
//--------------------------------------------------------------------------- // IFXString::Assign converter // // This method copies the source characters to the destination making any // conversions that are necessary //--------------------------------------------------------------------------- IFXRESULT IFXString::Assign(const IFXCHAR* pSource) { IFXRESULT result = IFX_OK; if(!pSource) { DeleteBuffer(); } else { NewBuffer((U32)wcslen(pSource)+1); if (m_Buffer) wcscpy(m_Buffer, pSource); else result = IFX_E_OUT_OF_MEMORY; } return result; }
EdpPacket* PacketCmdResp(const int8_t* cmdid, uint16_t cmdid_len, const int8_t* resp, uint32_t resp_len) { EdpPacket* send_pkg = NULL; unsigned remainlen = 0; send_pkg = NewBuffer(); /* 6 = 2 + 4 = len(cmdid_len) + len(resp_len) */ remainlen = cmdid_len + resp_len + (resp_len ? 6 : 2); WriteByte(send_pkg, CMDRESP); WriteRemainlen(send_pkg, remainlen); WriteUint16(send_pkg, cmdid_len); WriteBytes(send_pkg, cmdid, cmdid_len); if (resp_len) { WriteUint32(send_pkg, resp_len); WriteBytes(send_pkg, resp, resp_len); } return send_pkg; }
/* recv stream to a edp packet (S->C) */ EdpPacket* GetEdpPacket(RecvBuffer* buf) { //assert(buf->_read_pos == 0); EdpPacket* pkg = 0; int32 flag = IsPkgComplete(buf); if (flag <= 0) { return pkg; } pkg = NewBuffer(); WriteBytes(pkg, buf->_data, flag); /* shrink buffer */ mymemmove(buf->_data, buf->_data + flag, buf->_write_pos - flag); buf->_write_pos -= flag; return pkg; }
/* sava_data (C->S) */ EdpPacket* PacketSavedataJson(const char* dst_devid, cJSON* json_obj, int type) { EdpPacket* pkg = NewBuffer(); uint32 remainlen = 0; char* json_out = cJSON_Print(json_obj); uint32 json_len = mystrlen(json_out); //printjson(json_obj);//_hx_printf("json type=%d,c=0x%X,p=0x%X n=0x%X",json_obj->type,json_obj->child,json_obj->prev,json_obj->next); //return 0; /* msg type */ WriteByte(pkg, SAVEDATA); if (dst_devid) { /* remain len */ remainlen = 1+(2+mystrlen(dst_devid))+1+(2+json_len); WriteRemainlen(pkg, remainlen); /* translate address flag */ WriteByte(pkg, 0x80); /* dst devid */ WriteStr(pkg, dst_devid); } else { /* remain len */ remainlen = 1+1+(2+json_len); WriteRemainlen(pkg, remainlen); /* translate address flag */ WriteByte(pkg, 0x00); } /* json flag */ WriteByte(pkg, type); /* json */ WriteStr(pkg, json_out); hx_free(json_out); return pkg; }
/* sava_data (C->S) */ EdpPacket* PacketSavedataJson(const int8_t* dst_devid, cJSON* json_obj, int32_t type) { EdpPacket* pkg = NULL; uint32_t remainlen = 0; int8_t* json_out = NULL; uint32_t json_len = 0; pkg = NewBuffer(); json_out =(int8_t *) cJSON_Print(json_obj); json_len = strlen((const char *)json_out); /* msg type */ WriteByte(pkg, SAVEDATA); if (dst_devid) { /* remain len */ remainlen = 1 + (2 + strlen((const char *)dst_devid)) + 1 + (2 + json_len); WriteRemainlen(pkg, remainlen); /* translate address flag */ WriteByte(pkg, 0x80); /* dst devid */ WriteStr(pkg, dst_devid); } else { /* remain len */ remainlen = 1 + 1 + (2 + json_len); WriteRemainlen(pkg, remainlen); /* translate address flag */ WriteByte(pkg, 0x00); } /* json flag */ WriteByte(pkg, type); /* json */ WriteStr(pkg, json_out); printf("%s \n", json_out); free(json_out); return pkg; }
IFXString::IFXString(const char* operand) : m_Buffer(NULL), m_BufferLength(0) { if(!operand) { DeleteBuffer(); } else { U32 size = 0; IFXRESULT result = IFXOSGetWideCharStrSize( (const U8*)operand, &size ); size = size + 1; // null terminator if( IFXSUCCESS(result) && (size > 0) ) { NewBuffer(size); if (m_Buffer) IFXOSConvertUtf8StrToWideChar( (const U8*)operand, m_Buffer, size ); } } }
// &**&**&**&**&**&**&**&**&**&**&**&**&**&**&**&**&**&**& // Assignment Support // &**&**&**&**&**&**&**&**&**&**&**&**&**&**&**&**&**&**& //--------------------------------------------------------------------------- // IFXString::Assign // // This method copies the source characters to the destination buffer //--------------------------------------------------------------------------- IFXRESULT IFXString::Assign(const IFXString* pSource) { IFXRESULT result = IFX_OK; if(!pSource) { DeleteBuffer(); } else { if (pSource->m_BufferLength > 0) { NewBuffer(pSource->m_BufferLength); if (m_Buffer) wcscpy(m_Buffer, pSource->m_Buffer); else result = IFX_E_OUT_OF_MEMORY; } } return result; }
BOOL CCircuitry::OnDialPacket(CDialPacket* pPacket) { CSingleLock pLock( &Network.m_pSection, TRUE ); CHAR xRemoteId[MAX_PHONE + 1]; xRemoteId[ pPacket->GetRemoteId( xRemoteId ) ] = '\0'; CChannel* pChannel = Network.LookOutPhs( xRemoteId ); if ( ! pChannel ) return SendPacket( new CErrPacket( ECore_Busy ) ); int nChan = pChannel->m_nChan; SsmSetRecMixer( nChan, FALSE, 0 ); SsmSetDTMFStopRecCharSet( nChan, "" ); SsmSetDtmfStopPlay( nChan, FALSE ); pChannel->OnDialPacket( pPacket ); NewBuffer( nChan ); Start( nChan ); return TRUE; }
/* connect1 (C->S): devid + apikey */ EdpPacket* PacketConnect1(const char* devid, const char* auth_key) { EdpPacket* pkg = NewBuffer(); uint32 remainlen; /* msg type */ WriteByte(pkg, CONNREQ); /* remain len */ remainlen = (2+3)+1+1+2+(2+mystrlen(devid))+(2+mystrlen(auth_key)); WriteRemainlen(pkg, remainlen); /* protocol desc */ WriteStr(pkg, PROTOCOL_NAME); /* protocol version */ WriteByte(pkg, PROTOCOL_VERSION); /* connect flag */ WriteByte(pkg, 0x40); /* keep time */ WriteUint16(pkg, 0x0080); /* DEVID */ WriteStr(pkg, devid); /* auth key */ WriteStr(pkg, auth_key); return pkg; }
JNIEXPORT jobject JNICALL Java_com_aio4c_buffer_Buffer_allocate(JNIEnv* jvm, jclass clazz, jint capacity) { Buffer* buffer = NULL; jmethodID constructor = NULL; jobject jBuffer = NULL; jstring jmsg = NULL; CheckJNICall(jvm, (*jvm)->GetMethodID(jvm, clazz, "<init>", "()V"), constructor); CheckJNICall(jvm, (*jvm)->NewObject(jvm, clazz, constructor), jBuffer); buffer = NewBuffer(capacity); if (buffer == NULL) { CheckJNICall(jvm, (*jvm)->NewStringUTF(jvm, "cannot allocate buffer"), jmsg); RaiseJavaException( jvm, "java/lang/OutOfMemoryError", "(Ljava/lang/String;)V", jmsg); } else { SetPointer(jvm, jBuffer, buffer); } return jBuffer; }
int gameloop(void) { struct Buffer *buffer; int ticks; int c = 0; int cmd1, cmd2; int done = NO; time_t t; struct tm *tp; buffer = NewBuffer(); SetClip(0, 0, SCREEN_WIDTH - 1, SCREEN_HEIGHT - 1); if (ModuleStatus() != MODULE_OK) DisplayMessage(ModuleMessage()); gameIsPaused = NO; missionTime = 0; //screenShaking = 0; while (!done) { frames++; Ticks_FrameBegin(); ticks = Ticks_Synchronize(); if (gOptions.displaySlices) SetColorZero(32, 0, 0); DrawScreen(buffer, gPlayer1, gPlayer2); if (gOptions.displaySlices) SetColorZero(0, 0, 0); if (screenShaking) { screenShaking -= ticks; if (screenShaking < 0) screenShaking = 0; } debug(D_VERBOSE, "frames... %d\n", frames); if (Ticks_TimeElapsed(TICKS_PER_SEC)) { fps = frames; debug(D_NORMAL, "fps = %d\n", fps); frames = 0; t = time(NULL); tp = localtime(&t); timeHours = tp->tm_hour; timeMinutes = tp->tm_min; } if (messageTicks > 0) messageTicks -= ticks; StatusDisplay(); if (!gameIsPaused) { missionTime += ticks; if ((gPlayer1 || gPlayer2) && MissionCompleted()) { if (gMission.pickupTime == PICKUP_LIMIT) PlaySound(SND_DONE, 0, 255); gMission.pickupTime -= ticks; if (gMission.pickupTime <= 0) done = YES; } else gMission.pickupTime = PICKUP_LIMIT; } if (gOptions.displaySlices) SetColorZero(0, 0, 32); if (gOptions.displaySlices) SetColorZero(0, 0, 0); CopyToScreen(); if (!gameIsPaused) { if (!gOptions.slowmotion || (frames & 1) == 0) { UpdateAllActors(ticks); UpdateMobileObjects(); GetPlayerInput(&cmd1, &cmd2); if (gPlayer1 && !PlayerSpecialCommands( gPlayer1, cmd1, &gPlayer1Data)) { CommandActor(gPlayer1, cmd1); } if (gPlayer2 && !PlayerSpecialCommands( gPlayer2, cmd2, &gPlayer2Data)) { CommandActor(gPlayer2, cmd2); } if (gOptions.badGuys) CommandBadGuys(); UpdateWatches(); } } else { GetPlayerInput(&cmd1, &cmd2); } if (!gPlayer1 && !gPlayer2) { done = YES; c = 0; } else { c = HandleKey(&done, cmd1 | cmd2); } Ticks_FrameEnd(); } free(buffer); return c != keyEsc; }