Datasets:

Reset23

/

the-stack-v2-blamed-c

like 0

d3feaa79e326239b0a0d83cc023398d19d8e050f

f4a11c3b79215563a9ff8c4501a0e977c57488e8

/pru/libs/controller/pru_controller.c

28373192cf73f9db91bb74b67857dd6d024a0692

permissive

org-mylinuxdrone-project/org.mylinuxdrone.project

67b5a1d67ff8206e01b3f946000fa34faa48c41b

9ddd0a97e52c82cb3569acc05e8e809128c532c9

refs/heads/master

UTF-8

C

c

/* * pru_controller.c * Created on: 06 gen 2020 * Author: Andrea Lambruschini <andrea.lambruschini@gmail.com> * * Copyright 2019 Andrea Lambruschini * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include <pru_controller.h> /* * +------------+ * |Axis | * +------------+ * | Z Y | * | | / | * | |/ | * | /____ X | * +------------+ * +--------------+ * | Motors | * +--------------+ * | 3(cw) 1(ccw) | * | \ / | * | \/ | * | /\ | * | / \ | * | 2(ccw)4(cw) | * +--------------+ * * +-----------+ * |Dir.Accel | * +--+--+--+--+ * | 1| 2| 3| 4| * +--+--+--+--+--+ * |-1|-1| 1| 1| Y| * A= |-1| 1|-1| 1| P| * |-1| 1| 1|-1| R| * | 1| 1| 1| 1| T| * +--+--+--+--+--+ */ /* TODO: * Input: RC(i), Accel, Gyro tutti in LSB * I dati devono essere forniti in scala e già rispetto agli assi definiti (matrici direzione già applicate) * Stato: F, M, MErr, MIErr, MDErr, Throttle * Parametri: ke, ki, kd * Calcolo: * - MErr(i)=Throttle(i)- Gyro(i) * - MIErr(i)=MIErr(i-1) + MIErr(i) * - MDErr(i)=(MErr(i) - MErr(i-1))*Freq (1KHz) * - M(i)=+ke*MErr(i)) + ki*MIErr(i)+ kd*MDErr(i) * - F(i)=inv(A)*M(i) * Output:F(i) * l'output è inviato direttamente al controller motori. */ struct pru_controller_status pru_controller_status_val = { {0, 0, 0, 0}, // F {0, 0, 0, 0}, // MErr {0, 0, 0, 0}, // MIErr {0, 0, 0, 0}, // MDErr {0, 0, 0, 0} // M }; struct pru_controller_config pru_controller_config_val = { 0x0100, // ke: fix point 8 bits (0x0100 corrisponde a 1) 0x0000, // ki: fix point 8 bits 0x0000, // kd: fix point 8 bits 0x0100, // yke: fix point 8 bits (0x0100 corrisponde a 1) 0x0000, // yki: fix point 8 bits 0x0000, // ykd: fix point 8 bits 0x13, // kgyro: fix point 5 bit 0x04 // mas: num samples accel }; int8_t invA[4][4] = { {-1, -1, -1, 1 }, {-1, 1, 1, 1 }, { 1, -1, 1, 1 }, { 1, 1, -1, 1 } }; uint8_t pru_controller_enabled = 0; struct pru_controller_status* pru_controller_get_status() { return &pru_controller_status_val; } struct pru_controller_config* pru_controller_get_config() { return &pru_controller_config_val; } void pru_controller_init() { uint8_t i = 0; pru_controller_enabled = 0; for(i = 0; i < 4; i++) { pru_controller_status_val.F[i] = 0; pru_controller_status_val.M[i] = 0; pru_controller_status_val.MErr[i] = 0; pru_controller_status_val.MIErr[i] = 0; pru_controller_status_val.MDErr[i] = 0; } } void pru_controller_enable() { pru_controller_init(); pru_controller_enabled = 1; } void pru_controller_disable() { pru_controller_init(); } uint8_t pru_controller_is_enabled() { return pru_controller_enabled; } /* * TODO: il calcolo del pid ha senso solo se si è in volo ... * Come identificare se si è in volo o no? * Approssimare con posizione throttle ... */ void pru_controller_apply(int16_t* rc, int16_t* accel, int16_t* gyro) { uint8_t i = 0; uint8_t j = 0; int16_t prevErr = 0; if(pru_controller_enabled == 0) { return; } prevErr = pru_controller_status_val.MErr[POS_YAW]; pru_controller_status_val.MErr[POS_YAW] = LIMIT(rc[POS_YAW] - gyro[POS_YAW], 10000, -10000); pru_controller_status_val.MDErr[POS_YAW] = pru_controller_status_val.MErr[POS_YAW] - prevErr; pru_controller_status_val.MIErr[POS_YAW] += pru_controller_status_val.MErr[POS_YAW]; // <---TODO: Gestire limiti max, min pru_controller_status_val.M[POS_YAW] = ((pru_controller_config_val.yke*pru_controller_status_val.MErr[POS_YAW]) >> 8)+ ((pru_controller_config_val.yki*pru_controller_status_val.MIErr[POS_YAW]) >> 8) + ((pru_controller_config_val.ykd*pru_controller_status_val.MDErr[POS_YAW]) >> 8); prevErr = pru_controller_status_val.MErr[POS_PITCH]; pru_controller_status_val.MErr[POS_PITCH] = LIMIT(rc[POS_PITCH] - gyro[POS_PITCH], 10000, -10000); pru_controller_status_val.MDErr[POS_PITCH] = pru_controller_status_val.MErr[POS_PITCH] - prevErr; pru_controller_status_val.MIErr[POS_PITCH] += pru_controller_status_val.MErr[POS_PITCH]; // <---TODO: Gestire limiti max, min pru_controller_status_val.M[POS_PITCH] = ((pru_controller_config_val.ke*pru_controller_status_val.MErr[POS_PITCH]) >> 8)+ ((pru_controller_config_val.ki*pru_controller_status_val.MIErr[POS_PITCH]) >> 8) + ((pru_controller_config_val.kd*pru_controller_status_val.MDErr[POS_PITCH]) >> 8); prevErr = pru_controller_status_val.MErr[POS_ROLL]; pru_controller_status_val.MErr[POS_ROLL] = LIMIT(rc[POS_ROLL] - gyro[POS_ROLL], 10000, -10000); pru_controller_status_val.MDErr[POS_ROLL] = pru_controller_status_val.MErr[POS_ROLL] - prevErr; pru_controller_status_val.MIErr[POS_ROLL] += pru_controller_status_val.MErr[POS_ROLL]; // <---TODO: Gestire limiti max, min pru_controller_status_val.M[POS_ROLL] = ((pru_controller_config_val.ke*pru_controller_status_val.MErr[POS_ROLL]) >> 8)+ ((pru_controller_config_val.ki*pru_controller_status_val.MIErr[POS_ROLL]) >> 8) + ((pru_controller_config_val.kd*pru_controller_status_val.MDErr[POS_ROLL]) >> 8); /* TODO: * Per ora non verifico l'accelerazione verticale * sarà implementazione successiva */ pru_controller_status_val.MErr[POS_THROTTLE] = 0; pru_controller_status_val.MDErr[POS_THROTTLE] = 0; pru_controller_status_val.MIErr[POS_THROTTLE] = 0; pru_controller_status_val.M[POS_THROTTLE] = rc[POS_THROTTLE]; for(i = 0; i < 4; i++) { pru_controller_status_val.F[i] = 0; for(j = 0; j < 4; j++) { // invA corrisponde a 4*A^(-1) per questo >> 2 pru_controller_status_val.F[i] += ((invA[i][j]*pru_controller_status_val.M[j]) >> 2); } pru_controller_status_val.F[i] = MAX(0, pru_controller_status_val.F[i]); // non possono essere negative } /* TODO: * Inviare F al controller motori * Motori a 16KHz (duty minimo 5% del periodo, duty massimo 10% del periodo) * periodo circa 63 microsecondi. Verificare la risposta degli ESC. * * */ }

andrea.lambruschini@telecomitalia.it

fdb1ab0c6698d9fe649d7dbb68845fef034eb4ea

f08bbe3a9406fe3e39aa3c03eb979fdd88ea819a

/Oscillographer/EMWIN/STemWin/inc/GUIDRV_Dist.h

a6e47c4317c3dcb52a234fbdcea32f116e50cc22

no_license

lazode/MCU_Code

e41def826d7b812fe00db76bd288106d7acd37e3

1105eb8f289f9107d97b3dc9de0e50a456570964

refs/heads/master

UTF-8

C

h

/********************************************************************* * SEGGER Microcontroller GmbH & Co. KG * * Solutions for real time microcontroller applications * ********************************************************************** * * * (c) 1996 - 2015 SEGGER Microcontroller GmbH & Co. KG * * * * Internet: www.segger.com Support: support@segger.com * * * ********************************************************************** ** emWin V5.30 - Graphical user interface for embedded applications ** All Intellectual Property rights in the Software belongs to SEGGER. emWin is protected by international copyright laws. Knowledge of the source code may not be used to write a similar product. This file may only be used in accordance with the following terms: The software has been licensed to ARM LIMITED whose registered office is situated at 110 Fulbourn Road, Cambridge CB1 9NJ, England solely for the purposes of creating libraries for ARM7, ARM9, Cortex-M series, and Cortex-R4 processor-based devices, sublicensed and distributed as part of the MDK-ARM Professional under the terms and conditions of the End User License supplied with the MDK-ARM Professional. Full source code is available at: www.segger.com We appreciate your understanding and fairness. ---------------------------------------------------------------------- Licensing information Licensor: SEGGER Software GmbH Licensed to: ARM Ltd Licensed SEGGER software: emWin License number: GUI-00181 License model: LES-SLA-20007, Agreement, effective since October 1st 2011 Licensed product: MDK-ARM Professional Licensed platform: ARM7/9, Cortex-M/R4 Licensed number of seats: - ---------------------------------------------------------------------- File : GUIDRV_Dist.h Purpose : Interface definition for GUIDRV_Dist driver ---------------------------END-OF-HEADER------------------------------ */ #ifndef GUIDRV_DIST_H #define GUIDRV_DIST_H #if defined(__cplusplus) extern "C" { /* Make sure we have C-declarations in C++ programs */ #endif /********************************************************************* * * Display driver */ // // Address // extern const GUI_DEVICE_API GUIDRV_Dist_API; // // Macros to be used in configuration files // #if defined(WIN32) && !defined(LCD_SIMCONTROLLER) #define GUIDRV_DIST &GUIDRV_Win_API #else #define GUIDRV_DIST &GUIDRV_Dist_API #endif /********************************************************************* * * Public routines */ #if defined(WIN32) && !defined(LCD_SIMCONTROLLER) #define GUIDRV_Dist_AddDriver(pDevice, pDriver, pRect) #else void GUIDRV_Dist_AddDriver(GUI_DEVICE * pDevice, GUI_DEVICE * pDriver, GUI_RECT * pRect); #endif #if defined(__cplusplus) } #endif #endif /* GUIDRV_DIST_H */ /*************************** End of file ****************************/

lanzhuo_@hotmail.com

d58104b278162aaf063c1d3dd1b17f57f82d16ef

d63125caee9b6e9d54a29603da1680321cc884c4

/fibbronacci.c

4e1a528f466f420110501801465b37c8a6f844e7

no_license

Kishankr09/Even-Fibonacci-numbers

dcb2903f10808112f82f335334a0b24de5c76794

e9f9f3d023cebe91b872af250418364634d511cd

refs/heads/master

UTF-8

C

c

#include<stdio.h> #include<conio.h> int main() { long n,j,k,s=2; j=2; k=1; do { n=j+k; k=j; j=n; if(n%2==0) s=s+n; }while(n<=4000000); printf("even sum %d",s); getch(); }

noreply@github.com

9bbcc951c7d52cde4c38591cb385092b7241a32c

e1704387d3045c8a0d631839fb6e317ffbe01605

/rounding.c

b1cd609a6d89fd24c23ec4c0da25cb5eb5ea80dd

no_license

StevenXL/codeabbey

018f2e8a3e8473e24203313aa6bc74d287c602a6

bb60a78b55af4d364f4dfd880a802c354be99e20

refs/heads/master

UTF-8

C

c

#include <math.h> #include <stdio.h> #include <stdlib.h> int main(void) { // open file in read only mode FILE* inFile = fopen("rounding.txt", "r"); if (inFile == NULL) { printf("Unable to open file!\n"); return 1; } // create int var, store first line of file int num_pairs; fscanf(inFile, "%d", &num_pairs); // create array to hold pairs int* pairsArray; pairsArray = malloc (num_pairs * 2 * sizeof(int)); // read each line, add the pairs to our pairsArray int ii; for (ii = 0; ii < (num_pairs * 2); ii = ii + 2) { fscanf(inFile, "%d %d", &pairsArray[ii], &pairsArray[ii + 1]); } // create array to hold answers int* answersArray; answersArray = malloc (num_pairs * sizeof(int)); // find the answers and hold them in the array int jj = 0; int kk = 0; for (jj = 0, kk= 0; jj < (num_pairs * 2); jj = jj + 2, kk++) { float abs_div = fabsf( (float) pairsArray[jj] / pairsArray[jj + 1]); int int_div = abs( pairsArray[jj] / pairsArray[jj + 1] ); if ( (pairsArray[jj] / pairsArray[jj + 1]) > 0 ) { if ( (abs_div - int_div) >= 0.5 ) { answersArray[kk] = (pairsArray[jj] / pairsArray[jj + 1]) + 1; } else { answersArray[kk] = pairsArray[jj] / pairsArray[jj + 1]; } } else { if ( (abs_div - int_div) >= 0.5 ) { answersArray[kk] = (int_div + 1) * -1; } else { answersArray[kk] = int_div * -1; } } } // print answers int ll = 0; for (ll = 0; ll < num_pairs; ll++) { if (ll == (num_pairs - 1)) { printf("%d\n", answersArray[ll]); } else { printf("%d ", answersArray[ll]); } } return 0; }

leiva.steven@gmail.com

f84b1cf23f444182504ab29826f57e6435b39cac

a70324bf8e5cf644e66b93d002370b0618b4b56f

/includes/move_finger.h

e2ba7681df1bb9a839a6420f835d949d01afd2a4

no_license

bibaswan-bhawal/robotic-hand

7012e3dca7ba5f5fdc1954442a6529a32f4396dd

37212c89b83b8fa70c3220c0560de249c17a735b

refs/heads/main

UTF-8

C

h

#ifndef MOVE_FINGER_H #define MOVE_FINGER_H #include "Arduino.h" #include "var_def.h" void movefinger(Finger finger, int speed, int direction); #endif

bibaswan3600@gmail.com

b217cf352fd01dcd53f6d84df5144c03be758dd5

43441cde04695a2bf62a7a5f7db4072aa0a6d366

/vc60/G3D/Stdafx.h

52bd5687350a089aee5d51cb0558126e1952c8f6

no_license

crespo2014/cpp-lib

a8aaf4b963d3bf41f91db3832dd51bcf601d54ee

de6b653bf4c689fc5ceb3e9fe0f4fe47d79acf95

refs/heads/master

UTF-8

C

h

// stdafx.h : include file for standard system include files, // or project specific include files that are used frequently, but // are changed infrequently // #if !defined(AFX_STDAFX_H__8FC3CE27_AEEE_11D3_A036_0000E8DE4B3B__INCLUDED_) #define AFX_STDAFX_H__8FC3CE27_AEEE_11D3_A036_0000E8DE4B3B__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers #include <afxwin.h> // MFC core and standard components #include <afxext.h> // MFC extensions #ifndef _AFX_NO_OLE_SUPPORT #include <afxole.h> // MFC OLE classes #include <afxodlgs.h> // MFC OLE dialog classes #include <afxdisp.h> // MFC Automation classes #endif // _AFX_NO_OLE_SUPPORT #ifndef _AFX_NO_DB_SUPPORT #include <afxdb.h> // MFC ODBC database classes #endif // _AFX_NO_DB_SUPPORT #ifndef _AFX_NO_DAO_SUPPORT #include <afxdao.h> // MFC DAO database classes #endif // _AFX_NO_DAO_SUPPORT #include <afxdtctl.h> // MFC support for Internet Explorer 4 Common Controls #ifndef _AFX_NO_AFXCMN_SUPPORT #include <afxcmn.h> // MFC support for Windows Common Controls #endif // _AFX_NO_AFXCMN_SUPPORT #include <gl\gl.h> #include <gl\glu.h> #include <afxmt.h> #include "math.h" //{{AFX_INSERT_LOCATION}} // Microsoft Visual C++ will insert additional declarations immediately before the previous line. #endif // !defined(AFX_STDAFX_H__8FC3CE27_AEEE_11D3_A036_0000E8DE4B3B__INCLUDED_)

lester.crespo.es@gmail.com

f85279fed26ed221e934ec0179c20fbdbd9d1b1d

9bfd1035daefdc9037289089ed4e6d00b208b672

/src/image.h

8f64fd652643b8e2dddbdd1818a34d0c58f41f37

no_license

pjreddie/dl-hw1

bbb2a22e91b37b60a9ba6fb61b0ea2954a1bf63d

8440db1f85807f2fd33b18498a212a5f46619e8a

refs/heads/master

UTF-8

C

h

#ifndef IMAGE_H #define IMAGE_H #include <stdio.h> // DO NOT CHANGE THIS FILE #include "matrix.h" #define TWOPI 6.2831853 #define MIN(a,b) (((a)<(b))?(a):(b)) #define MAX(a,b) (((a)>(b))?(a):(b)) typedef struct{ int w,h,c; float *data; } image; // Basic operations float get_pixel(image im, int x, int y, int c); void set_pixel(image im, int x, int y, int c, float v); image copy_image(image im); void shift_image(image im, int c, float v); void scale_image(image im, int c, float v); void clamp_image(image im); image get_channel(image im, int c); int same_image(image a, image b); image sub_image(image a, image b); image add_image(image a, image b); // Loading and saving typedef enum{ PNG, BMP, TGA, JPG } IMAGE_TYPE; image make_image(int w, int h, int c); image float_to_image(float *data, int w, int h, int c); image load_image(char *filename); void save_image_options(image im, const char *name, IMAGE_TYPE f, int quality); void save_image(image im, const char *name); void free_image(image im); // Resizing float nn_interpolate(image im, float x, float y, int c); image nn_resize(image im, int w, int h); float bilinear_interpolate(image im, float x, float y, int c); image bilinear_resize(image im, int w, int h); // Used for saving images #endif

pjreddie@gmail.com

93aabd81aeb654a4f0c98886f687b127b3124af7

3d0de0f2549d9025540fcec88624c72c079b406f

/BSW/src/bsw/gen/CanIf/src/CanIf_TriggerTransmit.c

86228e4eb3c6f75359a840610685dce687fba441

no_license

ongbut999/Jenkins_Test

ee19936e1577bd93d2755d21299ed3fbec553db6

abb74480c4ce938dd1c7463627c4074071580af4

refs/heads/master

UTF-8

C

c

/* *************************************************************************************************** * Includes *************************************************************************************************** */ #include "CanIf_Prv.h" /* *************************************************************************************************** * used functions *************************************************************************************************** */ #if (CANIF_TRIGGERTRANSMIT_SUPPORT == STD_ON) #define CANIF_START_SEC_CODE #include "CanIf_MemMap.h" Std_ReturnType CanIf_TriggerTransmit(PduIdType TxPduId, PduInfoType* PduInfoPtr) { VAR (Std_ReturnType, AUTOMATIC ) lRetVal_en = E_NOT_OK; #if (CANIF_CFG_TX_FEATURE_ENABLED== STD_ON) /* Pointer to Tx Pdu configuration */ P2CONST(CanIf_Cfg_TxPduConfig_tst, AUTOMATIC, CANIF_CFG_CONST) lTxPduConfig_pst; VAR(uint16, AUTOMATIC) ltxPduCustId_t; /* If CAN Interface is uninitialized, report to DET and return E_NOT_OK */ CANIF_DET_REPORT_ERROR_NOT_OK((FALSE == CanIf_Prv_InitStatus_b), CANIF_TRIGGER_TRANSMIT_SID, CANIF_E_UNINIT) ltxPduCustId_t = CanIf_Prv_ConfigSet_tpst->TxPduIdTable_Ptr[TxPduId]; lTxPduConfig_pst = (CanIf_Prv_ConfigSet_tpst->CanIf_TxPduConfigPtr) + ltxPduCustId_t; /*TxPduId passed is always valid as it is sent by Canif to Can*/ if(lTxPduConfig_pst->TxPduTriggerTransmit == TRUE) { if(NULL_PTR != lTxPduConfig_pst->UserTriggerTransmit) { lRetVal_en = lTxPduConfig_pst->UserTriggerTransmit(TxPduId, PduInfoPtr); } } #endif return lRetVal_en; } #define CANIF_STOP_SEC_CODE #include "CanIf_MemMap.h" #endif

fixed-term.Truong.HuynhQuang@vn.bosch.com

519ccb0190db14fef617c8af9e2ac59b57620731

bcddcbd49bfc9101c05640525b0f32b60ffa0562

/libft/ft_isdigit.c

20e45149f1e564b42b8bdc98b716c2f72d9c5853

no_license

arodiono/lem-in

16169ba9955fb6742d00328b1ac2848847e3198d

9bae77270ae51a636f3b365fe9d7a4295c8416d5

refs/heads/master

UTF-8

C

c

/* ************************************************************************** */ /* */ /* ::: :::::::: */ /* ft_isdigit.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: arodiono <marvin@42.fr> +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/11/23 16:53:27 by arodiono #+# #+# */ /* Updated: 2016/11/23 16:57:35 by arodiono ### ########.fr */ /* */ /* ************************************************************************** */ int ft_isdigit(int ch) { if (ch > 47 && ch < 58) return (1); else return (0); }

arodiono@e1r5p7.unit.ua

8dc0d4d3dbded87f4679d55880984f02b50741fc

1c34c2aebd8294cddc9f7600d14d77bd007bffad

/ADC_CONFIGURATIONS_EXAMPLE1/src/asf.h

1d6120e7d5f6930ed7546d84ce894558a1fb7b59

no_license

Hamidreza-k/adc

a9b0b2975ab3ebc820aa4d45904f38115e5ceaed

0f784b20d22fcd5bd6b4badd29f156a0ed8c21cf

refs/heads/master

UTF-8

C

h

/** * \file * * \brief Autogenerated API include file for the Atmel Software Framework (ASF) * * Copyright (c) 2012 Atmel Corporation. All rights reserved. * * \asf_license_start * * \page License * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * 3. The name of Atmel may not be used to endorse or promote products derived * from this software without specific prior written permission. * * 4. This software may only be redistributed and used in connection with an * Atmel microcontroller product. * * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * * \asf_license_stop * */ #ifndef ASF_H #define ASF_H /* * This file includes all API header files for the selected drivers from ASF. * Note: There might be duplicate includes required by more than one driver. * * The file is automatically generated and will be re-written when * running the ASF driver selector tool. Any changes will be discarded. */ // From module: ADC - Analog-to-Digital Converter (Callback APIs) #include <adc.h> #include <adc_callback.h> // From module: Common SAM0 compiler driver #include <compiler.h> #include <status_codes.h> // From module: Delay routines #include <delay.h> // From module: EVSYS - Event System Common #include <events.h> // From module: EVSYS - Event System with interupt hooks support #include <events_hooks.h> // From module: Generic board support #include <board.h> // From module: Interrupt management - SAM implementation #include <interrupt.h> // From module: PORT - GPIO Pin Control #include <port.h> // From module: Part identification macros #include <parts.h> // From module: SERCOM Callback API #include <sercom.h> #include <sercom_interrupt.h> // From module: SERCOM USART - Serial Communications (Callback APIs) #include <usart.h> #include <usart_interrupt.h> // From module: SYSTEM - Clock Management for SAMD21/R21/DA/HA #include <clock.h> #include <gclk.h> // From module: SYSTEM - Core System Driver #include <system.h> // From module: SYSTEM - I/O Pin Multiplexer #include <pinmux.h> // From module: SYSTEM - Interrupt Driver #include <system_interrupt.h> // From module: SYSTEM - Power Management for SAM D20/D21/R21/D09/D10/D11/DA/HA #include <power.h> // From module: SYSTEM - Reset Management for SAM D20/D21/R21/D09/D10/D11/DA/HA #include <reset.h> // From module: Standard serial I/O (stdio) #include <stdio_serial.h> // From module: TC - Timer Counter (Callback APIs) #include <tc.h> #include <tc_interrupt.h> // From module: USART - Serial interface- SAM implementation for devices with only USART #include <serial.h> #endif // ASF_H

H.KHISHAVAND@GMAIL.com

b5241295a36ced51dc6cf50d3ecc9b7eaf3f2140

d4f05d3ce52560b8b91c9ba96f6c6f7324af3314

/main.c

125ab966fbc379db7457e030c5f9f57510e91810

no_license

matheyal/NF16-ABR

04a559728aa438f586cf05398a61dce451b0d55a

adf5b6018a5c54032eb1621d477dcf5ae1bc323b

refs/heads/master

UTF-8

C

c

#include "liste.h" #include "arbre.h" #include "outils.h" //outil.c : pb main 6 : avec certains mot. int main() { printf("Bonjour !\n\n"); /*Variables utilisées pour gérer le menu et les appels de fonction*/ int choix, mots_lus, fichier_charge=0; char* filename=(char*)malloc(200*sizeof(char)); char* filename2=(char*)malloc(200*sizeof(char)); char* mot=(char*)malloc(50*sizeof(char)); char* mot1=(char*)malloc(50*sizeof(char)); char* mot2=(char*)malloc(50*sizeof(char)); ArbreBR* a=NULL; /*Affichage de l'en-tete du programme */ printf("\tBienvenue dans votre programme de classement alphabetique de texte\n\n"); while(1) { printf("Menu principal : Veuillez choisir une fonction a effectuer \n"); printf("\t1 - Creer un arbre binaire de recherche\n"); printf("\t2 - Charger un fichier dans l'ABR\n"); printf("\t3 - Afficher les caracteristiques de l'ABR\n"); printf("\t4 - Afficher tous les mots distincts de l'ABR par ordre alphabetique\n"); printf("\t5 - Rechercher un mot dans l'ABR\n"); printf("\t6 - Afficher les phrases contenant les 2 mots saisis\n"); printf("\t7 - Afficher un fichier ligne par ligne\n"); printf("\t8 - Quitter le programme\n"); scanf("%d", &choix); switch (choix) { /*Création ABR*/ case 1: a=creer_abr(); if (a!=NULL) printf("Arbre cree !\n\n"); else printf("Erreur de création de l'arbre.\n\n"); break; /*Charger un fichier*/ case 2: if (a!=NULL) { printf("Veuillez saisir le fichier a charger en chemin relatif ou absolu : "); scanf("%s",filename); mots_lus=charger_fichier(a,filename); if (mots_lus==-1) printf("Veuillez verifier votre saisie de chemin.\n\n"); else { fichier_charge=1; if(mots_lus==0) printf("Aucun mot n'a pu etre lu !\n\n"); else printf("%d mots ont ete lus dans le fichier !\n\n",mots_lus); } } else printf("Impossible ! Arbre non cree !\n\n"); break; /*Afficher caractériqtiques ABR*/ case 3: if (a!=NULL) { printf("Nombre de mots total : %d\nNombre de noeuds : %d\nProfondeur de l'arbre : %d\n",a->nb_mots_total,a->nb_mots_differents,hauteur_arbre(a)); if (est_equilibre(a->racine)) printf("Arbre equilibre.\n\n"); else printf("Arbre non equilibre.\n\n"); } else printf("Impossible ! Arbre non cree !\n\n"); break; /*Afficher mots distincts*/ case 4: if (a!=NULL) { afficher_arbre(*a); printf("\n"); } else printf("Impossible ! Arbre non cree !\n\n"); break; /*Rechercher un mot*/ case 5: if (a!=NULL) { printf("\nVeuillez saisir le mot a rechercher : "); scanf("%s",mot); mot2=StringToLower(mot); char* nom1 = (char*)malloc(strlen(mot2)); memcpy(nom1, mot2, strlen(mot2)+1); NoeudABR* x=rechercher_noeud(a,nom1); afficher_position(x); } else printf("Impossible ! Arbre non cree !\n\n"); break; /*Recherche de phrase à partir de 2 mots*/ case 6: if (a!=NULL) { if(fichier_charge) { printf("Veuillez saisir les mots recherches : "); scanf("%s %s",mot, mot1); afficher_phrases(a,mot,mot1,filename); } else printf("Impossible ! Aucun fichier charge dans l'ABR.\n\n"); } else { printf("Impossible ! Arbre non cree.\n\n"); } break; /*Affichage d'un fichier texte */ case 7: printf("Veuillez saisir le fichier a afficher en chemin relatif ou absolu : "); scanf("%s",filename2); afficher_fichier(filename2); break; /*Quitter le programme et rendre les allocations */ case 8: free(filename); free(filename2); free(mot); free(mot1); free_arbre(a, a->racine); printf("Au revoir !\n"); return 0; default: printf("Commande non reconnue.\n\n"); break; } } }

alex.mathey78@gmail.com

9371a19c502fd81fc0b7dc7ba3a570f978387bce

2dbfaaf469b864698c33e1849059a41b76812659

/Phase-2-UAV-Experimental-Platform-June/CAmkES_sel4_VM/slang_libraries/SW_Impl_Instance_RADIO_RadioDriver_Attestation/ext/RadioDriver_Attestation_thr_Impl_Impl_api.h

a6e4e89737d16eb2cc01304a919ce3bc1dcc3c8c

no_license

loonwerks/case-ta6-experimental-platform-models

e12b92aced4841cb6b785718e9af4c8da9a370b6

fe273e2fdbac92b3553a9e9dbf6d5738a5431e17

refs/heads/master

C

UTF-8

C

h

../../../../hamr/src/c/ext-c/RadioDriver_Attestation_thr_Impl_Impl/RadioDriver_Attestation_thr_Impl_Impl_api.h

egm@cs.byu.edu

b44fd3b9a001535f1927033ca48a5be1527afbc9

5c255f911786e984286b1f7a4e6091a68419d049

/vulnerable_code/abd0265d-4c43-4805-b898-2b1b1c979923.c

23953ab547c8114b260ca41cdefa2d94afd81f67

no_license

nmharmon8/Deep-Buffer-Overflow-Detection

70fe02c8dc75d12e91f5bc4468cf260e490af1a4

e0c86210c86afb07c8d4abcc957c7f1b252b4eb2

refs/heads/master

UTF-8

C

c

#include <string.h> #include <stdio.h> int main() { int i=0; int j=14; int k; int l; k = 53; l = 64; k = i/j; l = i/j; l = i/j; l = l/j; l = k%j; l = k-j; k = k-k*i; //variables //random /* START VULNERABILITY */ int a; int b[69]; int c[47]; a = 0; while (( a - 1 ) > -1) { a--; /* START BUFFER SET */ *((int *)c + ( a - 1 )) = *((int *)b + ( a - 1 )); /* END BUFFER SET */ //random } /* END VULNERABILITY */ //random printf("%d%d\n",k,l); return 0; }

nharmon8@gmail.com

11f27fb7a445127a9afcd94f9d2f85e2f1f703ef

a95227278641ba65e6a09f77c6320bbdc9359886

/130.c

d4c4f6c7ae153190a8b79d2634ab4ce280a46df4

no_license

MANOJTMK/player13

868bb171fd34f14ef4a4787ed1e8d43b308feb71

59b0c76be80745e46af83fbb6970fa6514b1fecc

refs/heads/master

UTF-8

C

c

#include <stdio.h> #include<conio.h> int main(void) { int n; scanf("%d",&n); int a[n],i,sum=0; for(i=0;i<n;i++) { scanf("%d ",&a[i]); } for(i=0;i<n;i++) { sum=sum+a[i]; if(sum%2==0) { printf("%d ",sum); } else { printf("%d ",a[i]); } } return 0; }

noreply@github.com

0fb33c31617130aca08fba96332d0338ab13c50c

fa19a9c2e6ca05a67ebb4bf5b1dfa1b00f90fe3b

/src/h4_path_hpm.h

585c025e4349f1ec49f9a10b4439f06ab54663cc

no_license

gwwilburn/HPMHomology

95aa73cfdd9d29db58831b33521814b3143b897f

5b6725bbf29b431983fd581e4b03d2e64cdc1bf0

refs/heads/master

UTF-8

C

h

/* h4_path_hpm.h*/ /* Grey's functions with h4 paths */ #ifndef h4PATHHPM_INCLUDED #define h4PATHHPM_INCLUDED #include <stdlib.h> #include <stdio.h> #include <stdarg.h> #include "easel.h" #include "esl_alphabet.h" #include "esl_msa.h" #include "h4_config.h" #include "h4_mode.h" #include "h4_profile.h" #include "h4_path.h" extern int h4_path_FromMSA(ESL_MSA *msa, int8_t *matassign, int optflags, H4_PATH **pi); extern int h4_path_DumpAnnotated(FILE *fp, const H4_PATH *pi, const H4_PROFILE *hmm, const H4_MODE *mo, const ESL_DSQ *dsq); #endif

wilburn@g.harvard.edu

cf0612c57b36d6c3644efc482aac3bd55cf2ddac

9a3b9d80afd88e1fa9a24303877d6e130ce22702

/src/Providers/UNIXProviders/StorageRelocationService/UNIX_StorageRelocationServicePrivate.h

9d7da4ab60cb56f61e80e76b7ba21d841b109555

permissive

brunolauze/openpegasus-providers

3244b76d075bc66a77e4ed135893437a66dd769f

f24c56acab2c4c210a8d165bb499cd1b3a12f222

refs/heads/master

UTF-8

C

h

//%LICENSE//////////////////////////////////////////////////////////////// // // Licensed to The Open Group (TOG) under one or more contributor license // agreements. Refer to the OpenPegasusNOTICE.txt file distributed with // this work for additional information regarding copyright ownership. // Each contributor licenses this file to you under the OpenPegasus Open // Source License; you may not use this file except in compliance with the // License. // // Permission is hereby granted, free of charge, to any person obtaining a // copy of this software and associated documentation files (the "Software"), // to deal in the Software without restriction, including without limitation // the rights to use, copy, modify, merge, publish, distribute, sublicense, // and/or sell copies of the Software, and to permit persons to whom the // Software is furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // ////////////////////////////////////////////////////////////////////////// // //%///////////////////////////////////////////////////////////////////////// #if defined(PEGASUS_OS_HPUX) # include "UNIX_StorageRelocationServicePrivate_HPUX.h" #elif defined(PEGASUS_OS_LINUX) # include "UNIX_StorageRelocationServicePrivate_LINUX.h" #elif defined(PEGASUS_OS_DARWIN) # include "UNIX_StorageRelocationServicePrivate_DARWIN.h" #elif defined(PEGASUS_OS_AIX) # include "UNIX_StorageRelocationServicePrivate_AIX.h" #elif defined(PEGASUS_OS_FREEBSD) # include "UNIX_StorageRelocationServicePrivate_FREEBSD.h" #elif defined(PEGASUS_OS_SOLARIS) # include "UNIX_StorageRelocationServicePrivate_SOLARIS.h" #elif defined(PEGASUS_OS_ZOS) # include "UNIX_StorageRelocationServicePrivate_ZOS.h" #elif defined(PEGASUS_OS_VMS) # include "UNIX_StorageRelocationServicePrivate_VMS.h" #elif defined(PEGASUS_OS_TRU64) # include "UNIX_StorageRelocationServicePrivate_TRU64.h" #else # include "UNIX_StorageRelocationServicePrivate_STUB.h" #endif

brunolauze@msn.com

26516eeb302ec10ec5ccb915df2051c0ec08a920

805666a84218be543410ff5089588f1572dd20ec

/d/quanzhou/yongning.c

405b9906349c5168742a6fa1ccc739e6c54c8adc

no_license

mudchina/xkx2001

d47a9caca686ab7c89fe0b9140fbaf9d3601e1f5

4e8f8a13a72884d5dbe4b589542eb34e29e89d70

refs/heads/master

GB18030

C

c

//Cracked by Roath // yongning.c 永宁港 // qfy Nov 3, 1996 // modified by aln #include <ansi.h> inherit HARBOR; void create() { set("short", "永宁港"); set("long", @LONG 永宁港是泉州三大港口之一。这里港阔水深，风平浪静。极目远眺，海天 一色，蔚蓝无暇。岸边停靠着密密麻麻的各种船只。南边的姑嫂塔流传着一个 感人的故事。 LONG ); set("exits", ([ /* sizeof() == 4 */ "south" : __DIR__"gushao", "northwest" : __DIR__"gangkou2", ])); set("objects", ([ __DIR__"npc/tiao-fu" : 1, __DIR__"npc/kuli" : 1, ])); set("no_clean_up", 0); set("outdoors", "quanzhou"); set("navigate/locx", 0); set("navigate/locy", -280); set("cost", 1); setup(); }

liming.xie@gmail.com

1ab6078efe73ef412931f3ea46d4b43180afd40b

e81220623f8e27b9df4364cd41cd63ed0edf9d72

/NavigationDG/jni/3rdParty/fftw3/dft/scalar/codelets/t2_4.c

75a1fa2547ed0d038a03aebcafea77b6938909a2

permissive

jwietrzykowski/DiamentowyGrant

f04514812e7e4f46815f073e3df3820d5f7501cd

490470eff4cacc04102109e25a17044da8273c89

refs/heads/master

UTF-8

C

c

/* * Copyright (c) 2003, 2007-8 Matteo Frigo * Copyright (c) 2003, 2007-8 Massachusetts Institute of Technology * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * */ /* This file was automatically generated --- DO NOT EDIT */ /* Generated on Sun Jul 12 06:37:48 EDT 2009 */ #include "../../codelet-dft.h" #ifdef HAVE_FMA /* Generated by: ../../../genfft/gen_twiddle -fma -reorder-insns -schedule-for-pipeline -compact -variables 4 -pipeline-latency 4 -twiddle-log3 -precompute-twiddles -n 4 -name t2_4 -include t.h */ /* * This function contains 24 FP additions, 16 FP multiplications, * (or, 16 additions, 8 multiplications, 8 fused multiply/add), * 33 stack variables, 0 constants, and 16 memory accesses */ #include "../t.h" static void t2_4(float *ri, float *ii, const float *W, stride rs, INT mb, INT me, INT ms) { INT m; for (m = mb, W = W + (mb * 4); m < me; m = m + 1, ri = ri + ms, ii = ii + ms, W = W + 4, MAKE_VOLATILE_STRIDE(rs)) { E Ti, Tq, To, Te, Ty, Tz, Tm, Ts; { E T2, T6, T3, T5; T2 = W[0]; T6 = W[3]; T3 = W[2]; T5 = W[1]; { E T1, Tx, Td, Tw, Tj, Tl, Ta, T4, Tk, Tr; T1 = ri[0]; Ta = T2 * T6; T4 = T2 * T3; Tx = ii[0]; { E T8, Tb, T7, Tc; T8 = ri[WS(rs, 2)]; Tb = FNMS(T5, T3, Ta); T7 = FMA(T5, T6, T4); Tc = ii[WS(rs, 2)]; { E Tf, Th, T9, Tv, Tg, Tp; Tf = ri[WS(rs, 1)]; Th = ii[WS(rs, 1)]; T9 = T7 * T8; Tv = T7 * Tc; Tg = T2 * Tf; Tp = T2 * Th; Td = FMA(Tb, Tc, T9); Tw = FNMS(Tb, T8, Tv); Ti = FMA(T5, Th, Tg); Tq = FNMS(T5, Tf, Tp); } Tj = ri[WS(rs, 3)]; Tl = ii[WS(rs, 3)]; } To = T1 - Td; Te = T1 + Td; Ty = Tw + Tx; Tz = Tx - Tw; Tk = T3 * Tj; Tr = T3 * Tl; Tm = FMA(T6, Tl, Tk); Ts = FNMS(T6, Tj, Tr); } } { E Tn, TA, Tu, Tt; Tn = Ti + Tm; TA = Ti - Tm; Tu = Tq + Ts; Tt = Tq - Ts; ii[WS(rs, 3)] = TA + Tz; ii[WS(rs, 1)] = Tz - TA; ri[0] = Te + Tn; ri[WS(rs, 2)] = Te - Tn; ri[WS(rs, 1)] = To + Tt; ri[WS(rs, 3)] = To - Tt; ii[WS(rs, 2)] = Ty - Tu; ii[0] = Tu + Ty; } } } static const tw_instr twinstr[] = { {TW_CEXP, 0, 1}, {TW_CEXP, 0, 3}, {TW_NEXT, 1, 0} }; static const ct_desc desc = { 4, "t2_4", twinstr, &fftwf_dft_t_genus, {16, 8, 8, 0}, 0, 0, 0 }; void fftwf_codelet_t2_4 (planner *p) { fftwf_kdft_dit_register (p, t2_4, &desc); } #else /* HAVE_FMA */ /* Generated by: ../../../genfft/gen_twiddle -compact -variables 4 -pipeline-latency 4 -twiddle-log3 -precompute-twiddles -n 4 -name t2_4 -include t.h */ /* * This function contains 24 FP additions, 16 FP multiplications, * (or, 16 additions, 8 multiplications, 8 fused multiply/add), * 21 stack variables, 0 constants, and 16 memory accesses */ #include "../t.h" static void t2_4(float *ri, float *ii, const float *W, stride rs, INT mb, INT me, INT ms) { INT m; for (m = mb, W = W + (mb * 4); m < me; m = m + 1, ri = ri + ms, ii = ii + ms, W = W + 4, MAKE_VOLATILE_STRIDE(rs)) { E T2, T4, T3, T5, T6, T8; T2 = W[0]; T4 = W[1]; T3 = W[2]; T5 = W[3]; T6 = FMA(T2, T3, T4 * T5); T8 = FNMS(T4, T3, T2 * T5); { E T1, Tp, Ta, To, Te, Tk, Th, Tl, T7, T9; T1 = ri[0]; Tp = ii[0]; T7 = ri[WS(rs, 2)]; T9 = ii[WS(rs, 2)]; Ta = FMA(T6, T7, T8 * T9); To = FNMS(T8, T7, T6 * T9); { E Tc, Td, Tf, Tg; Tc = ri[WS(rs, 1)]; Td = ii[WS(rs, 1)]; Te = FMA(T2, Tc, T4 * Td); Tk = FNMS(T4, Tc, T2 * Td); Tf = ri[WS(rs, 3)]; Tg = ii[WS(rs, 3)]; Th = FMA(T3, Tf, T5 * Tg); Tl = FNMS(T5, Tf, T3 * Tg); } { E Tb, Ti, Tn, Tq; Tb = T1 + Ta; Ti = Te + Th; ri[WS(rs, 2)] = Tb - Ti; ri[0] = Tb + Ti; Tn = Tk + Tl; Tq = To + Tp; ii[0] = Tn + Tq; ii[WS(rs, 2)] = Tq - Tn; } { E Tj, Tm, Tr, Ts; Tj = T1 - Ta; Tm = Tk - Tl; ri[WS(rs, 3)] = Tj - Tm; ri[WS(rs, 1)] = Tj + Tm; Tr = Tp - To; Ts = Te - Th; ii[WS(rs, 1)] = Tr - Ts; ii[WS(rs, 3)] = Ts + Tr; } } } } static const tw_instr twinstr[] = { {TW_CEXP, 0, 1}, {TW_CEXP, 0, 3}, {TW_NEXT, 1, 0} }; static const ct_desc desc = { 4, "t2_4", twinstr, &fftwf_dft_t_genus, {16, 8, 8, 0}, 0, 0, 0 }; void fftwf_codelet_t2_4 (planner *p) { fftwf_kdft_dit_register(p, t2_4, &desc); } #endif /* HAVE_FMA */

michalsminowicki@gmail.com

95e6949088651e36b7b514e5ef9004f89e7e7752

496db11ab732538b6d7f486a3afc3c5593abebc9

/src/guide/FUSION.H

c0e682d8bc2094bff947791b14694047521a68ea

no_license

luckialuo/4rotor

74502a86640e4ae324d9d625ed220246ed2df335

f1993832fd3e32b29949cfff1bd772088a266ca1

refs/heads/code

C

GB18030

C

h

#ifndef _FUSION_H_ #define _FUSION_H_ extern FP32 ac_lon, ac_lat; /*[经度/纬度]*/ extern FP32 ac_Vd, /*[地速]*/ ac_psi, /*[真航向][0~360]*/ psi_cat; extern FP32 ac_height; extern INT32S info_alt; /*[高度信息源]*/ extern INT16S dL_mix0, dZ_mix0; void fusion_refresh_gps(FP32 lon, FP32 lat, FP32 psi); void fusion_guide(void); void fusion_slow(void); #endif

luckialuo@gmail.com

98e55fd99cc5141ee22b5e3e008a1b3b9eb21a97

28be9376f20320248283114ca82938b7561a3f76

/PWM_Code/lpc_chip_5411x_m0/inc/spi_common_5411x.h

d50aca447fcd7a889268b10169e67b71d0ecdbce

no_license

ankitjhall/Project_Pixybot

5f08b4c1fea7f4c492fb89d373e1dea706ac6ce7

85bf0f825e1c9fa48516a7ba3ff5b8ff19b8e73d

refs/heads/master

UTF-8

C

h

/* * @brief LPC5411X SPI common functions and definitions * * @note * Copyright(C) NXP Semiconductors, 2015 * All rights reserved. * * @par * Software that is described herein is for illustrative purposes only * which provides customers with programming information regarding the * LPC products. This software is supplied "AS IS" without any warranties of * any kind, and NXP Semiconductors and its licensor disclaim any and * all warranties, express or implied, including all implied warranties of * merchantability, fitness for a particular purpose and non-infringement of * intellectual property rights. NXP Semiconductors assumes no responsibility * or liability for the use of the software, conveys no license or rights under any * patent, copyright, mask work right, or any other intellectual property rights in * or to any products. NXP Semiconductors reserves the right to make changes * in the software without notification. NXP Semiconductors also makes no * representation or warranty that such application will be suitable for the * specified use without further testing or modification. * * @par * Permission to use, copy, modify, and distribute this software and its * documentation is hereby granted, under NXP Semiconductors' and its * licensor's relevant copyrights in the software, without fee, provided that it * is used in conjunction with NXP Semiconductors microcontrollers. This * copyright, permission, and disclaimer notice must appear in all copies of * this code. */ #ifndef __SPI_COMMON_5411X_H_ #define __SPI_COMMON_5411X_H_ #ifdef __cplusplus extern "C" { #endif /** @defgroup SPI_COMMON_5411X CHIP: LPC5411X SPI driver * * The SPI interface is provided via FlexCOMM module in the CHIP, to associate a SPI to * a flexcom the source file must add a define like <b>\#define SPI0_FLEXCOMM 5</b> which * will make LPC_SPI0 use LPC_FLEXCOMM5, interrupt service function name and IRQ number * DMA REQUEST number will all be mapped automatically. <b> Note that this define must * be available/visible to all the sources that uses SPI.</b><br><br> The SPI driver * by default will use FIFOs for TX and RX. TX and RX FIFOs has a depth of 8 entries each. * * @ingroup CHIP_5411X_DRIVERS * @{ */ /** * @brief SPI register block structure */ typedef struct { /*!< SPI Structure */ /** SPI registers @endcond */ __I uint32_t RESERVED0[256]; __IO uint32_t CFG; /*!< Offset: 0x400 SPI Configuration register */ __IO uint32_t DLY; /*!< Offset: 0x404 SPI Delay register */ __IO uint32_t STAT; /*!< Offset: 0x408 SPI Status register */ __IO uint32_t INTENSET; /*!< Offset: 0x40c SPI Interrupt Enable Set register */ __IO uint32_t INTENCLR; /*!< Offset: 0x410 SPI Interrupt Enable Clear register */ __I uint32_t RESERVED1[4]; __IO uint32_t DIV; /*!< Offset: 0x424 SPI clock Divider register */ __IO uint32_t INTSTAT; /*!< Offset: 0x428 SPI Interrupt Status register @cond */ __I uint32_t RESERVED2[629]; /** SPI FIFO Specific registers @endcond */ __IO uint32_t FIFOCFG; /*!< Offset: 0xE00 FIFO Configuration register */ __IO uint32_t FIFOSTAT; /*!< Offset: 0xE04 FIFO Status register */ __IO uint32_t FIFOTRIG; /*!< Offset: 0xE08 FIFO Trigger level register @cond */ __I uint32_t RESERVED3; /*!< Offset: 0xE0C Reserved register @endcond */ __IO uint32_t FIFOINTENSET; /*!< Offset: 0xE10 FIFO Interrupt enable SET register */ __IO uint32_t FIFOINTENCLR; /*!< Offset: 0xE14 FIFO Interrupt enable CLEAR register */ __IO uint32_t FIFOINTSTAT; /*!< Offset: 0xE18 FIFO Interrupt Status register @cond */ __I uint32_t RESERVED4; /*!< Offset: 0xE1C Reserved register @endcond */ __O uint32_t FIFOWR; /*!< Offset: 0xE20 FIFO Data write register @cond */ __I uint32_t RESERVED5[3]; /*!< Offset: 0xE24 Reserved register @endcond */ __I uint32_t FIFORD; /*!< Offset: 0xE30 FIFO Data read register @cond */ __I uint32_t RESERVED6[3]; /*!< Offset: 0xE24 Reserved register @endcond */ __I uint32_t FIFORDNOPOP; /*!< Offset: 0xE40 FIFO Data peek (read without popping out of queue) register @cond */ __I uint32_t RESERVED7[109]; /*!< Offset: 0xE44 Reserved register */ /** FLEXCOMM Interface registers @endcond */ __IO uint32_t PSELID; /*!< Offset: 0xFF8 Peripheral select/identification register */ __I uint32_t PID; /*!< Offset: 0xFFC Module identification register */ } LPC_SPI_T; /** * Macro defines for SPI Configuration register */ #define SPI_CFG_BITMASK (0x0FBD) /** SPI register bit mask */ #define SPI_CFG_SPI_EN (1 << 0) /** SPI Slave Mode Select */ #define SPI_CFG_SLAVE_EN (0 << 0) /** SPI Master Mode Select */ #define SPI_CFG_MASTER_EN (1 << 2) /** SPI MSB First mode enable */ #define SPI_CFG_MSB_FIRST_EN (0 << 3) /** SPI LSB First mode enable */ #define SPI_CFG_LSB_FIRST_EN (1 << 3) /** SPI Clock Phase Select */ #define SPI_CFG_CPHA_FIRST (0 << 4) /** Capture data on the first edge, Change data on the following edge */ #define SPI_CFG_CPHA_SECOND (1 << 4) /** SPI Clock Polarity Select */ #define SPI_CFG_CPOL_LO (0 << 5) /** The rest state of the clock (between frames) is low. */ #define SPI_CFG_CPOL_HI (1 << 5) /** The rest state of the clock (between frames) is high. */ #define SPI_CFG_LBM_EN (1 << 7) /** SPI control 1 loopback mode enable */ #define SPI_CFG_SPOL_LO (0 << 8) /** SPI SSEL0 Polarity Select */ #define SPI_CFG_SPOL_HI (1 << 8) /** SSEL0 is active High */ #define SPI_CFG_SPOLNUM_HI(n) (1 << ((n) + 8)) /** SSELN is active High, selects 0 - 3 */ /** * Macro defines for SPI Delay register */ #define SPI_DLY_BITMASK (0xFFFF) /** SPI DLY Register Mask */ #define SPI_DLY_PRE_DELAY(n) (((n) & 0x0F) << 0) /** Time in SPI clocks between SSEL assertion and the beginning of a data frame */ #define SPI_DLY_POST_DELAY(n) (((n) & 0x0F) << 4) /** Time in SPI clocks between the end of a data frame and SSEL deassertion. */ #define SPI_DLY_FRAME_DELAY(n) (((n) & 0x0F) << 8) /** Minimum time in SPI clocks between adjacent data frames. */ #define SPI_DLY_TRANSFER_DELAY(n) (((n) & 0x0F) << 12) /** Minimum time in SPI clocks that the SSEL is deasserted between transfers. */ /** * Macro defines for SPI Status register */ #define SPI_STAT_BITMASK (0x01F0) /** SPI STAT Register BitMask */ #define SPI_STAT_SSA (1 << 4) /** Slave Select Assert */ #define SPI_STAT_SSD (1 << 5) /** Slave Select Deassert */ #define SPI_STAT_STALLED (1 << 6) /** Stalled status flag */ #define SPI_STAT_EOT (1 << 7) /** End Transfer flag */ #define SPI_STAT_MSTIDLE (1 << 8) /** Idle status flag */ /** * Macro defines for SPI interrupt register */ #define SPI_INT_BITMASK (0x0130) /** SPI interrupt Enable/Disable bits */ #define SPI_INT_SSAEN (1 << 4) /** Slave Select is asserted interrupt [BIT-4 of INTENSET/INTENCLR/INTSTAT register] */ #define SPI_INT_SSDEN (1 << 5) /** Slave Select is deasserted interrupt [BIT-5 of INTENSET/INTENCLR/INTSTAT register] */ #define SPI_INT_MSTIDLE (1 << 8) /** SPI master is Idle [BIT-8 of INTENSET/INTENCLR/INTSTAT register] */ /** * @brief SPI FIFO Configuration register bits * @cond */ #define SPI_FIFOCFG_MASK (0x3F033) /*!< Register mask bit @endcond */ #define SPI_FIFOCFG_ENABLETX (1 << 0) /*!< Enable TX FIFO */ #define SPI_FIFOCFG_ENABLERX (1 << 1) /*!< Enable RX FIFO */ #define SPI_FIFOCFG_DMATX (1 << 12) /*!< Enable DMA TX */ #define SPI_FIFOCFG_DMARX (1 << 13) /*!< Enable DMA RX */ #define SPI_FIFOCFG_WAKETX (1 << 14) /*!< Enable wakeup triggered by TX */ #define SPI_FIFOCFG_WAKERX (1 << 15) /*!< Enable wakeup triggered by RX */ #define SPI_FIFOCFG_EMPTYTX (1 << 16) /*!< Empty the TX FIFO */ #define SPI_FIFOCFG_EMPTYRX (1 << 17) /*!< Empty the RX FIFO */ /** * @brief Macro defines for FIFO Status register */ #define SPI_FIFO_DEPTH (8) /** SPI-FIFO How many entries are in the FIFO */ #define SPI_FIFOSTAT_BITMASK (0x1F1FFB) /** SPI-FIFO STAT Register BitMask */ #define SPI_FIFOSTAT_TXERR (1 << 0) /** SPI-FIFO transmit error */ #define SPI_FIFOSTAT_RXERR (1 << 1) /** SPI-FIFO receive error */ #define SPI_FIFOSTAT_PERINT (1 << 3) /** SPI-FIFO peripheral (SPI) interrupt */ #define SPI_FIFOSTAT_TXEMPTY (1 << 4) /** SPI-FIFO transmitter empty */ #define SPI_FIFOSTAT_TXNOTFULL (1 << 5) /** SPI-FIFO transmitter not full */ #define SPI_FIFOSTAT_RXNOTEMPTY (1 << 6) /** SPI-FIFO receiver not empty */ #define SPI_FIFOSTAT_RXFULL (1 << 7) /** SPI-FIFO receiver not full */ #define SPI_FIFOSTAT_TXLVL(val) (((val) >> 8) & 0x1F) /** SPI-FIFO extract transmit level */ #define SPI_FIFOSTAT_RXLVL(val) (((val) >> 16) & 0x1F) /** SPI-FIFO extract receive level */ /** * @brief UART FIFO trigger settings register defines */ #define SPI_FIFOTRIG_BITMASK (0x000f0f03) /** SPI FIFO trigger settings Register BitMask */ #define SPI_FIFOTRIG_TXLVLENA (1 << 0) /*!< TX level enable*/ #define SPI_FIFOTRIG_RXLVLENA (1 << 1) /*!< RX level enable */ #define SPI_FIFOTRIG_TXLVL(lvl) ((lvl & 0x0f) << 8) /*!< Set TX Level trigger */ #define SPI_FIFOTRIG_RXLVL(lvl) ((lvl & 0x0f) << 16) /*!< Set RX Level trigger */ #define SPI_FIFOTRIG_TXLVL_DEFAULT 4 /*!< Set TX default trigger level to half-full */ #define SPI_FIFOTRIG_RXLVL_DEFAULT 0 /*!< Set RX default trigger level to one item */ /** * @brief Macro defines for SPI Interrupt enable/disable/status [INTSET/INTCLR/INTSTAT and FIFOINTSET/FIFOINTCLR/FIFOINTSTAT registers] */ #define SPI_FIFOINT_BITMASK (0x001F) /** FIFO interrupt Bit mask */ #define SPI_FIFOINT_TXERR (1 << 0) /** TX error interrupt [BIT-0 of FIFOINTENSET/FIFOINTENCLR/FIFOINTSTAT register] */ #define SPI_FIFOINT_RXERR (1 << 1) /** RX error interrupt [BIT-1 of FIFOINTENSET/FIFOINTENCLR/FIFOINTSTAT register] */ #define SPI_FIFOINT_TXLVL (1 << 2) /** TX FIFO ready interrupt [BIT-2 of FIFOINTENSET/FIFOINTENCLR/FIFOINTSTAT register] */ #define SPI_FIFOINT_RXLVL (1 << 3) /** RX Data ready interrupt [BIT-3 of FIFOINTENSET/FIFOINTENCLR/FIFOINTSTAT register] */ #define SPI_FIFOINT_PERINT (1 << 4) /** SPI peripheral interrupt [BIT-4 of FIFOINTSTAT register] */ /** * Macro defines for SPI FIFO Receiver Data register */ #define SPI_RXDAT_BITMASK (0x1FFFFF) /** SPI RXDAT Register BitMask */ #define SPI_RXDAT_DATA(n) ((n) & 0xFFFF) /** Receiver Data */ #define SPI_RXDAT_RXSSELN(n) ((~((n >> 16) & 0x0f)) & 0x0f) /** Determine the active SSEL pin */ #define SPI_RXDAT_RXSSELN_ACTIVE (0 << 16) /** The state of SSEL pin is active */ #define SPI_RXDAT_SOT (1 << 20) /** Start of Transfer flag */ /** * Macro defines for SPI FIFO Transmitter Data and Control register */ #define SPI_TXDAT_BITMASK (0xF7FFFFF) /** SPI TXDATCTL Register BitMask */ #define SPI_TXDAT_DATA(n) ((n) & 0xFFFF) /** SPI Transmit Data */ #define SPI_TXDAT_CTRLMASK (0xF7F) /** SPI TXDATCTL Register BitMask for control bits only */ #define SPI_TXDAT_ASSERT_SSEL (0) /** Assert SSEL0 pin */ #define SPI_TXDAT_ASSERTNUM_SSEL(n) ((~(1 << (n))) & 0x0f) /** Assert SSELN pin */ #define SPI_TXDAT_DEASSERT_SSEL (1) /** Deassert SSEL0 pin */ #define SPI_TXDAT_DEASSERTNUM_SSEL(n) (1 << (n)) /** Deassert SSELN pin */ #define SPI_TXDAT_DEASSERT_ALL (0xF) /** Deassert all SSEL pins */ #define SPI_TXDAT_EOT (1 << 4) /** End of Transfer flag (TRANSFER_DELAY is applied after sending the current frame) */ #define SPI_TXDAT_EOF (1 << 5) /** End of Frame flag (FRAME_DELAY is applied after sending the current part) */ #define SPI_TXDAT_RXIGNORE (1 << 6) /** Receive Ignore Flag */ #define SPI_TXDAT_FLEN(n) (((n) & 0x0F) << 8) /** Frame length - 1 */ #define SPI_TXDAT_FLENMASK (0xF << 8) /** Frame length mask */ /** * Macro defines for SPI Transmitter Data Register */ #define SPI_TXDAT_DATA(n) ((n) & 0xFFFF) /** SPI Transmit Data */ /** * Macro defines for SPI Divider register */ #define SPI_DIV_VAL(n) ((n) & 0xFFFF) /** Rate divider value mask (In Master Mode only)*/ /** @brief SPI Clock Mode*/ typedef enum { ROM_SPI_CLOCK_CPHA0_CPOL0 = 0, /**< CPHA = 0, CPOL = 0 */ ROM_SPI_CLOCK_MODE0 = ROM_SPI_CLOCK_CPHA0_CPOL0, /**< Alias for CPHA = 0, CPOL = 0 */ ROM_SPI_CLOCK_CPHA1_CPOL0 = 1, /**< CPHA = 0, CPOL = 1 */ ROM_SPI_CLOCK_MODE1 = ROM_SPI_CLOCK_CPHA1_CPOL0, /**< Alias for CPHA = 0, CPOL = 1 */ ROM_SPI_CLOCK_CPHA0_CPOL1 = 2, /**< CPHA = 1, CPOL = 0 */ ROM_SPI_CLOCK_MODE2 = ROM_SPI_CLOCK_CPHA0_CPOL1, /**< Alias for CPHA = 1, CPOL = 0 */ ROM_SPI_CLOCK_CPHA1_CPOL1 = 3, /**< CPHA = 1, CPOL = 1 */ ROM_SPI_CLOCK_MODE3 = ROM_SPI_CLOCK_CPHA1_CPOL1, /**< Alias for CPHA = 1, CPOL = 1 */ } ROM_SPI_CLOCK_MODE_T; /** * @brief Initialize the SPI * @param pSPI : The base SPI peripheral on the chip * @return Nothing */ int Chip_SPI_Init(LPC_SPI_T *pSPI); /** * @brief Disable SPI operation * @param pSPI : Base on-chip SPI peripheral address * @return Nothing * @note The SPI controller is disabled. */ __STATIC_INLINE void Chip_SPI_DeInit(LPC_SPI_T *pSPI) { Chip_FLEXCOMM_DeInit(pSPI); } /** * @brief Set SPI CFG register values * @param pSPI : Base on-chip SPI peripheral address * @param bits : CFG register bits to set, amd OR'ed value of SPI_CFG_* definitions * @return Nothing * @note This function safely sets only the selected bits in the SPI CFG register. * It can be used to enable multiple bits at once. */ __STATIC_INLINE void Chip_SPI_SetCFGRegBits(LPC_SPI_T *pSPI, uint32_t bits) { pSPI->CFG = (pSPI->CFG & SPI_CFG_BITMASK) | bits; } /** * @brief Clear SPI CFG register values * @param pSPI : Base on-chip SPI peripheral address * @param bits : CFG register bits to clear, amd OR'ed value of SPI_CFG_* definitions * @return Nothing * @note This function safely clears only the selected bits in the SPI CFG register. * It can be used to disable multiple bits at once. */ __STATIC_INLINE void Chip_SPI_ClearCFGRegBits(LPC_SPI_T *pSPI, uint32_t bits) { pSPI->CFG = pSPI->CFG & (~bits & SPI_CFG_BITMASK); } /** * @brief Enable SPI peripheral * @param pSPI : Base on-chip SPI peripheral address * @return Nothing */ __STATIC_INLINE void Chip_SPI_Enable(LPC_SPI_T *pSPI) { Chip_SPI_SetCFGRegBits(pSPI, SPI_CFG_SPI_EN); } /** * @brief Disable SPI peripheral * @param pSPI : Base on-chip SPI peripheral address * @return Nothing */ __STATIC_INLINE void Chip_SPI_Disable(LPC_SPI_T *pSPI) { Chip_SPI_ClearCFGRegBits(pSPI, SPI_CFG_SPI_EN); } /** * @brief Enable SPI slave mode * @param pSPI : Base on-chip SPI peripheral address * @return Nothing * @note SPI master mode will be disabled with this call. */ __STATIC_INLINE void Chip_SPI_EnableSlaveMode(LPC_SPI_T *pSPI) { Chip_SPI_ClearCFGRegBits(pSPI, SPI_CFG_MASTER_EN); } /** * @brief Enable LSB First transfers * @param pSPI : Base on-chip SPI peripheral address * @return Nothing */ __STATIC_INLINE void Chip_SPI_EnableLSBFirst(LPC_SPI_T *pSPI) { Chip_SPI_SetCFGRegBits(pSPI, SPI_CFG_LSB_FIRST_EN); } /** * @brief Enable MSB First transfers * @param pSPI : Base on-chip SPI peripheral address * @return Nothing */ __STATIC_INLINE void Chip_SPI_EnableMSBFirst(LPC_SPI_T *pSPI) { Chip_SPI_ClearCFGRegBits(pSPI, SPI_CFG_LSB_FIRST_EN); } /** @brief SPI Clock Mode*/ typedef enum IP_SPI_CLOCK_MODE { SPI_CLOCK_CPHA0_CPOL0 = SPI_CFG_CPOL_LO | SPI_CFG_CPHA_FIRST, /**< CPHA = 0, CPOL = 0 */ SPI_CLOCK_MODE0 = SPI_CLOCK_CPHA0_CPOL0, /**< Alias for CPHA = 0, CPOL = 0 */ SPI_CLOCK_CPHA1_CPOL0 = SPI_CFG_CPOL_LO | SPI_CFG_CPHA_SECOND, /**< CPHA = 0, CPOL = 1 */ SPI_CLOCK_MODE1 = SPI_CLOCK_CPHA1_CPOL0, /**< Alias for CPHA = 0, CPOL = 1 */ SPI_CLOCK_CPHA0_CPOL1 = SPI_CFG_CPOL_HI | SPI_CFG_CPHA_FIRST, /**< CPHA = 1, CPOL = 0 */ SPI_CLOCK_MODE2 = SPI_CLOCK_CPHA0_CPOL1, /**< Alias for CPHA = 1, CPOL = 0 */ SPI_CLOCK_CPHA1_CPOL1 = SPI_CFG_CPOL_HI | SPI_CFG_CPHA_SECOND, /**< CPHA = 1, CPOL = 1 */ SPI_CLOCK_MODE3 = SPI_CLOCK_CPHA1_CPOL1, /**< Alias for CPHA = 1, CPOL = 1 */ } SPI_CLOCK_MODE_T; /** * @brief Set SPI mode * @param pSPI : Base on-chip SPI peripheral address * @param mode : SPI mode to set the SPI interface to * @return Nothing */ __STATIC_INLINE void Chip_SPI_SetSPIMode(LPC_SPI_T *pSPI, SPI_CLOCK_MODE_T mode) { Chip_SPI_ClearCFGRegBits(pSPI, (SPI_CFG_CPOL_HI | SPI_CFG_CPHA_SECOND)); Chip_SPI_SetCFGRegBits(pSPI, (uint32_t) mode); } /** * @brief Set polarity on the SPI chip select high * @param pSPI : Base on-chip SPI peripheral address * @param csNum : Chip select number, 0 - 3 * @return Nothing * @note SPI chip select polarity is active high. */ __STATIC_INLINE void Chip_SPI_SetCSPolHigh(LPC_SPI_T *pSPI, uint8_t csNum) { Chip_SPI_SetCFGRegBits(pSPI, SPI_CFG_SPOLNUM_HI(csNum)); } /** * @brief Set polarity on the SPI chip select low * @param pSPI : Base on-chip SPI peripheral address * @param csNum : Chip select number, 0 - 3 * @return Nothing * @note SPI chip select polarity is active low. */ __STATIC_INLINE void Chip_SPI_SetCSPolLow(LPC_SPI_T *pSPI, uint8_t csNum) { Chip_SPI_ClearCFGRegBits(pSPI, SPI_CFG_SPOLNUM_HI(csNum)); } /** SPI configuration structure used for setting up master/slave mode, LSB or * MSB first, and SPI mode in a single function call. */ typedef struct { uint32_t master : 8; /* Set to non-0 value to use master mode, 0 for slave */ uint32_t lsbFirst : 8; /* Set to non-0 value to send LSB first, 0 for MSB first */ SPI_CLOCK_MODE_T mode : 8; /* Mode selection */ uint32_t reserved : 8; /* Reserved, for alignment only */ } SPI_CFGSETUP_T; /** * @brief Setup SPI configuration * @param pSPI : Base on-chip SPI peripheral address * @param pCFG : Pointer to SPI configuration structure * @return Nothing */ void Chip_SPI_ConfigureSPI(LPC_SPI_T *pSPI, SPI_CFGSETUP_T *pCFG); /** * @brief Get the current status of SPI controller * @param pSPI : Base on-chip SPI peripheral address * @return SPI Status (Or-ed bit value of SPI_STAT_*) * @note Mask the return value with a value of type SPI_STAT_* to determine * if that status is active. */ __STATIC_INLINE uint32_t Chip_SPI_GetStatus(LPC_SPI_T *pSPI) { return pSPI->STAT; } /** * @brief Clear SPI status * @param pSPI : Base on-chip SPI peripheral address * @param Flag : Clear Flag (Or-ed bit value of SPI_STAT_*) * @return Nothing */ __STATIC_INLINE void Chip_SPI_ClearStatus(LPC_SPI_T *pSPI, uint32_t Flag) { pSPI->STAT = Flag; } /** * @brief Enable a SPI interrupt * @param pSPI : Base on-chip SPI peripheral address * @param intMask : Or'ed value of SPI_INT_* values to enable * @return Nothing */ __STATIC_INLINE void Chip_SPI_EnableInts(LPC_SPI_T *pSPI, uint32_t intMask) { pSPI->INTENSET = intMask & SPI_INT_BITMASK; } /** * @brief Disable a SPI interrupt * @param pSPI : Base on-chip SPI peripheral address * @param intMask : Or'ed value of SPI_INT_* values to disable (See #SPI_INT_BITMASK) * @return Nothing */ __STATIC_INLINE void Chip_SPI_DisableInts(LPC_SPI_T *pSPI, uint32_t intMask) { pSPI->INTENCLR = intMask & SPI_INT_BITMASK; } /** * @brief Return enabled SPI interrupts * @param pSPI : Base on-chip SPI peripheral address * @return An Or'ed value of SPI_INT_* values * @note Mask the return value with a SPI_INT_* value to determine (See #SPI_INT_BITMASK) * if the interrupt is enabled. * @note INTSTAT contains enabled interrupts, not pending interrupts. */ __STATIC_INLINE uint32_t Chip_SPI_GetEnabledInts(LPC_SPI_T *pSPI) { return pSPI->INTSTAT & SPI_INT_BITMASK; } /** * @brief Return pending SPI interrupts * @param pSPI : Base on-chip SPI peripheral address * @return An Or'ed value of SPI_INT_* values */ __STATIC_INLINE uint32_t Chip_SPI_GetPendingInts(LPC_SPI_T *pSPI) { uint32_t stat, mask; mask = pSPI->INTSTAT; stat = pSPI->STAT; stat &= mask; return stat; } //------------------------------------------------------------------------------ // // End SPI functions / Start of FIFO functions // //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ // FIFO configuration functions //------------------------------------------------------------------------------ /** * @brief Set FIFO Configuration register * @param pSPI : Base on-chip SPI peripheral address * @param cfg : Configuration value mask (OR'ed SPI_FIFOCFG_* values like #SPI_FIFOCFG_ENABLETX) * @return Nothing */ __STATIC_INLINE void Chip_SPI_SetFIFOCfg(LPC_SPI_T *pSPI, uint32_t cfg) { pSPI->FIFOCFG = (pSPI->FIFOCFG & SPI_FIFOCFG_MASK) | cfg; } /** * @brief Clear FIFO Configuration register * @param pSPI : Base on-chip SPI peripheral address * @param cfg : Configuration value mask (OR'ed SPI_FIFOCFG_* values like #SPI_FIFOCFG_ENABLETX) * @return Nothing */ __STATIC_INLINE void Chip_SPI_ClearFIFOCfg(LPC_SPI_T *pSPI, uint32_t cfg) { pSPI->FIFOCFG = pSPI->FIFOCFG & (SPI_FIFOCFG_MASK & ~cfg); } //------------------------------------------------------------------------------ // FIFO status functions //------------------------------------------------------------------------------ /** * @brief Get the current status of SPI controller FIFO * @param pSPI : Base on-chip SPI peripheral address * @return SPI Status (Or-ed bit value of SPI_FIFOSTAT_*) * @note Mask the return value with a value of type SPI_FIFOSTAT_* to determine * if that status is active. */ __STATIC_INLINE uint32_t Chip_SPI_GetFIFOStatus(LPC_SPI_T *pSPI) { return pSPI->FIFOSTAT; } /** * @brief Clear the FIFO status register * @param pSPI : Base on-chip SPI peripheral address * @param mask : Mask of the status bits that needs to be cleared * @return Nothing */ __STATIC_INLINE void Chip_SPI_ClearFIFOStatus(LPC_SPI_T *pSPI, uint32_t mask) { pSPI->FIFOSTAT = mask; } //------------------------------------------------------------------------------ // FIFO trigger functions //------------------------------------------------------------------------------ /** * @brief Setup SPI FIFO trigger-level * @param pSPI : Base on-chip SPI peripheral address * @param tx_lvl : TX Trigger level [Valid values 0 to 7] * @param rx_lvl : RX Trigger level [Valid values 0 to 7] * @return Nothing * @note When @a tx_lvl = 0; trigger will happen when TX FIFO is empty * if @a tx_lvl = 7; trigger will happen when TX FIFO has at least one free space<br> * When @a rx_lvl = 0; trigger will happen when RX FIFO has at least one data in it, * if @a rx_lvl = 7; trigger will happen when RX FIFO is full and cannot receive anymore data. */ __STATIC_INLINE void Chip_SPI_SetFIFOTrigLevel(LPC_SPI_T *pSPI, uint8_t tx_lvl, uint8_t rx_lvl) { pSPI->FIFOTRIG = SPI_FIFOTRIG_TXLVL(tx_lvl) | SPI_FIFOTRIG_RXLVL(rx_lvl) |SPI_FIFOTRIG_TXLVLENA | SPI_FIFOTRIG_TXLVLENA; } /** * @brief Get SPI FIFO trigger-level * @param pSPI : Base of on-chip SPI peripheral * @return Returns the complete raw trigger register. */ __STATIC_INLINE uint32_t Chip_SPI_GetFIFOTrigLevel(LPC_SPI_T *pSPI) { return pSPI->FIFOTRIG; } //------------------------------------------------------------------------------ // FIFO interrupt functions //------------------------------------------------------------------------------ /** * @brief Enable a SPI FIFO interrupt * @param pSPI : Base on-chip SPI peripheral address * @param intMask : Or'ed value of SPI_FIFOINT_* values to enable * @return Nothing */ __STATIC_INLINE void Chip_SPI_EnableFIFOInts(LPC_SPI_T *pSPI, uint32_t intMask) { pSPI->FIFOINTENSET = intMask & SPI_FIFOINT_BITMASK; } /** * @brief Disable a SPI FIFO interrupt * @param pSPI : Base on-chip SPI peripheral address * @param intMask : Or'ed value of SPI_FIFOINT_* values to disable (See #SPI_FIFOINT_BITMASK) * @return Nothing */ __STATIC_INLINE void Chip_SPI_DisableFIFOInts(LPC_SPI_T *pSPI, uint32_t intMask) { pSPI->FIFOINTENCLR = intMask & SPI_FIFOINT_BITMASK; } /** * @brief Return enabled SPI FIFO interrupts * @param pSPI : Base on-chip SPI peripheral address * @return An Or'ed value of SPI_FIFOINT_* values */ __STATIC_INLINE uint32_t Chip_SPI_GetFIFOEnabledInts(LPC_SPI_T *pSPI) { return pSPI->FIFOINTENSET & SPI_FIFOINT_BITMASK; } /** * @brief Return pending SPI FIFO interrupts * @param pSPI : Base on-chip SPI peripheral address * @return An Or'ed value of SPI_FIFOINT_* values */ __STATIC_INLINE uint32_t Chip_SPI_GetFIFOPendingInts(LPC_SPI_T *pSPI) { return pSPI->FIFOINTSTAT & SPI_FIFOINT_BITMASK; } //------------------------------------------------------------------------------ // FIFO I/O functions //------------------------------------------------------------------------------ /** * @brief Read raw data from receive FIFO with status bits * @param pSPI : Base on-chip SPI peripheral address * @return Current value in receive data FIFO plus status bits */ __STATIC_INLINE uint32_t Chip_SPI_ReadRawRXFifo(LPC_SPI_T *pSPI) { return pSPI->FIFORD; } #define Chip_SPI_ReadFIFO Chip_SPI_ReadRawRXFifo /** * @brief Read data from receive FIFO masking off status bits * @param pSPI : Base on-chip SPI peripheral address * @return Current value in receive data FIFO * @note The entire register is read, but only the low 16-bits * are returned. */ __STATIC_INLINE uint16_t Chip_SPI_ReadRXData(LPC_SPI_T *pSPI) { __I void *ptr = &pSPI->FIFORD; return *((__I uint16_t *) ptr); } #define Chip_SPI_ReadFIFOdata Chip_SPI_ReadRXData /** * @brief Write FIFOWR register: writes 32-bit value to FIFO * @param pSPI : Base on-chip SPI peripheral address * @param data : Control and Data to be transfered * @return Nothing */ __STATIC_INLINE void Chip_SPI_WriteFIFO(LPC_SPI_T *pSPI, uint32_t data) { pSPI->FIFOWR = data; } /** * @brief Write FIFOWR register: writes control options and data * @param pSPI : Base on-chip SPI peripheral address * @param ctrl : Control bits to be set * @param data : Data to be transfered * @return Nothing * @note This function safely sets only set bits in FIFOWR control register. * It can be used to enable multiple options at once. */ __STATIC_INLINE void Chip_SPI_SetTXCTRLData(LPC_SPI_T *pSPI, uint16_t ctrl, uint16_t data) { pSPI->FIFOWR = (ctrl << 16) | data; } #define Chip_SPI_WriteFIFOcd Chip_SPI_SetTXCTRLData /** * @brief Write data to transmit FIFO * @param pSPI : Base on-chip SPI peripheral address * @param data : Data to write * @return Nothing */ __STATIC_INLINE void Chip_SPI_WriteTXData(LPC_SPI_T *pSPI, uint16_t data) { __O void *ptr = &pSPI->FIFOWR; *((__O uint16_t *) ptr) = data; } #define Chip_SPI_WriteFIFOdata Chip_SPI_WriteTXData /** * @brief Flush FIFOs * @param pSPI : Base on-chip SPI peripheral address * @return Nothing */ __STATIC_INLINE void Chip_SPI_FlushFifos(LPC_SPI_T *pSPI) { Chip_SPI_SetFIFOCfg(pSPI, SPI_FIFOCFG_EMPTYTX | SPI_FIFOCFG_EMPTYRX); } #define Chip_SPI_FlushFIFOs Chip_SPI_FlushFifos #ifndef __DOXYGEN__ /* SPI0 Defines */ #define LPC_SPI0_BASE __APPEND3(LPC_FLEXCOMM,SPI0_FLEXCOMM,_BASE) #define LPC_SPI0 ((LPC_SPI_T *) LPC_SPI0_BASE) #define SPI0_IRQHandler __APPEND3(FLEXCOMM,SPI0_FLEXCOMM,_IRQHandler) #define SPI0_IRQn __APPEND3(FLEXCOMM,SPI0_FLEXCOMM,_IRQn) #define DMAREQ_SPI0_RX __APPEND3(DMAREQ_FLEXCOMM,SPI0_FLEXCOMM,_RX) #define DMAREQ_SPI0_TX __APPEND3(DMAREQ_FLEXCOMM,SPI0_FLEXCOMM,_TX) /* SPI1 Defines */ #define LPC_SPI1_BASE __APPEND3(LPC_FLEXCOMM,SPI1_FLEXCOMM,_BASE) #define LPC_SPI1 ((LPC_SPI_T *) LPC_SPI1_BASE) #define SPI1_IRQHandler __APPEND3(FLEXCOMM,SPI1_FLEXCOMM,_IRQHandler) #define SPI1_IRQn __APPEND3(FLEXCOMM,SPI1_FLEXCOMM,_IRQn) #define DMAREQ_SPI1_RX __APPEND3(DMAREQ_FLEXCOMM,SPI1_FLEXCOMM,_RX) #define DMAREQ_SPI1_TX __APPEND3(DMAREQ_FLEXCOMM,SPI1_FLEXCOMM,_TX) /* SPI2 Defines */ #define LPC_SPI2_BASE __APPEND3(LPC_FLEXCOMM,SPI2_FLEXCOMM,_BASE) #define LPC_SPI2 ((LPC_SPI_T *) LPC_SPI2_BASE) #define SPI2_IRQHandler __APPEND3(FLEXCOMM,SPI2_FLEXCOMM,_IRQHandler) #define SPI2_IRQn __APPEND3(FLEXCOMM,SPI2_FLEXCOMM,_IRQn) #define DMAREQ_SPI2_RX __APPEND3(DMAREQ_FLEXCOMM,SPI2_FLEXCOMM,_RX) #define DMAREQ_SPI2_TX __APPEND3(DMAREQ_FLEXCOMM,SPI2_FLEXCOMM,_TX) /* SPI3 Defines */ #define LPC_SPI3_BASE __APPEND3(LPC_FLEXCOMM,SPI3_FLEXCOMM,_BASE) #define LPC_SPI3 ((LPC_SPI_T *) LPC_SPI3_BASE) #define SPI3_IRQHandler __APPEND3(FLEXCOMM,SPI3_FLEXCOMM,_IRQHandler) #define SPI3_IRQn __APPEND3(FLEXCOMM,SPI3_FLEXCOMM,_IRQn) #define DMAREQ_SPI3_RX __APPEND3(DMAREQ_FLEXCOMM,SPI3_FLEXCOMM,_RX) #define DMAREQ_SPI3_TX __APPEND3(DMAREQ_FLEXCOMM,SPI3_FLEXCOMM,_TX) /* SPI4 Defines */ #define LPC_SPI4_BASE __APPEND3(LPC_FLEXCOMM,SPI4_FLEXCOMM,_BASE) #define LPC_SPI4 ((LPC_SPI_T *) LPC_SPI4_BASE) #define SPI4_IRQHandler __APPEND3(FLEXCOMM,SPI4_FLEXCOMM,_IRQHandler) #define SPI4_IRQn __APPEND3(FLEXCOMM,SPI4_FLEXCOMM,_IRQn) #define DMAREQ_SPI4_RX __APPEND3(DMAREQ_FLEXCOMM,SPI4_FLEXCOMM,_RX) #define DMAREQ_SPI4_TX __APPEND3(DMAREQ_FLEXCOMM,SPI4_FLEXCOMM,_TX) /* SPI5 Defines */ #define LPC_SPI5_BASE __APPEND3(LPC_FLEXCOMM,SPI5_FLEXCOMM,_BASE) #define LPC_SPI5 ((LPC_SPI_T *) LPC_SPI5_BASE) #define SPI5_IRQHandler __APPEND3(FLEXCOMM,SPI5_FLEXCOMM,_IRQHandler) #define SPI5_IRQn __APPEND3(FLEXCOMM,SPI5_FLEXCOMM,_IRQn) #define DMAREQ_SPI5_RX __APPEND3(DMAREQ_FLEXCOMM,SPI5_FLEXCOMM,_RX) #define DMAREQ_SPI5_TX __APPEND3(DMAREQ_FLEXCOMM,SPI5_FLEXCOMM,_TX) /* SPI6 Defines */ #define LPC_SPI6_BASE __APPEND3(LPC_FLEXCOMM,SPI6_FLEXCOMM,_BASE) #define LPC_SPI6 ((LPC_SPI_T *) LPC_SPI6_BASE) #define SPI6_IRQHandler __APPEND3(FLEXCOMM,SPI6_FLEXCOMM,_IRQHandler) #define SPI6_IRQn __APPEND3(FLEXCOMM,SPI6_FLEXCOMM,_IRQn) #define DMAREQ_SPI6_RX __APPEND3(DMAREQ_FLEXCOMM,SPI6_FLEXCOMM,_RX) #define DMAREQ_SPI6_TX __APPEND3(DMAREQ_FLEXCOMM,SPI6_FLEXCOMM,_TX) /* SPI7 Defines */ #define LPC_SPI7_BASE __APPEND3(LPC_FLEXCOMM,SPI7_FLEXCOMM,_BASE) #define LPC_SPI7 ((LPC_SPI_T *) LPC_SPI7_BASE) #define SPI7_IRQHandler __APPEND3(FLEXCOMM,SPI7_FLEXCOMM,_IRQHandler) #define SPI7_IRQn __APPEND3(FLEXCOMM,SPI7_FLEXCOMM,_IRQn) #define DMAREQ_SPI7_RX __APPEND3(DMAREQ_FLEXCOMM,SPI7_FLEXCOMM,_RX) #define DMAREQ_SPI7_TX __APPEND3(DMAREQ_FLEXCOMM,SPI7_FLEXCOMM,_TX) #endif /** * @} */ #ifdef __cplusplus } #endif #endif /* __SPI_COMMON_5411X_H_ */

ankitjhall33@gmail.com

96863f5fae2e7c1f7dfa5b94409f7f243208783b

d683b22f6b58a5c29350ab8088215f246bf2d184

/admission criteria.c

ece3c24b9ce1570bc1cfa58e7a1b40c5c44a63fb

no_license

hvn4k/C

ff9517000f669b659398fb7ca92b99c1b5b528a9

60b34e2cca333c599b2335dbc7262aa7447bd6aa

refs/heads/main

UTF-8

C

c

#include<stdio.h> void func(int m , int p , int c) { if(m>=65 || p>=55 || c>=50) { printf("ADMISSION ACCEPTED"); } else if(m+p+c>=180) { printf("ADMISSION ACCEPTED"); } else if(m+p>=140) { printf("ADMISSION ACCEPTED"); } else { printf("ADMISSION NOT ACCEPTED"); } } main() { int m,p,c; printf("Enter marks in Maths"); scanf("%d",&m); printf("Enter marks in physics"); scanf("%d",&p); printf("Enter marks in Chemistry"); scanf("%d",&c); func(m,p,c); }

noreply@github.com

e959db03dfcb3736ed80c3dccc0a5f0d2a6c349f

caf26a8bb8ffe570e699d9c968c2b447b1f399ba

/firmware/Back_FC/MAVLINK/minimal/mavlink_msg_gps_status.h

d8673bd8688814160361437266db9e9adc5182fe

no_license

bygreencn/Oldx_fly_controller

d07bfd00b29b6ebe4d1c76cc7eb02240ca6d47aa

021cd924378f77e56d89289ee5c4e864ea787402

refs/heads/master

UTF-8

C

h

// MESSAGE GPS_STATUS PACKING #ifndef _MAVLINK_MSG_GPS_STATUS_H_ #define _MAVLINK_MSG_GPS_STATUS_H_ #include "../mavlink_helpers.h" #define MAVLINK_MSG_ID_GPS_STATUS 25 typedef struct __mavlink_gps_status_t { uint8_t satellites_visible; /*< Number of satellites visible*/ uint8_t satellite_prn[20]; /*< Global satellite ID*/ uint8_t satellite_used[20]; /*< 0: Satellite not used, 1: used for localization*/ uint8_t satellite_elevation[20]; /*< Elevation (0: right on top of receiver, 90: on the horizon) of satellite*/ uint8_t satellite_azimuth[20]; /*< Direction of satellite, 0: 0 deg, 255: 360 deg.*/ uint8_t satellite_snr[20]; /*< Signal to noise ratio of satellite*/ } mavlink_gps_status_t; #define MAVLINK_MSG_ID_GPS_STATUS_LEN 101 #define MAVLINK_MSG_ID_25_LEN 101 #define MAVLINK_MSG_ID_GPS_STATUS_CRC 23 #define MAVLINK_MSG_ID_25_CRC 23 #define MAVLINK_MSG_GPS_STATUS_FIELD_SATELLITE_PRN_LEN 20 #define MAVLINK_MSG_GPS_STATUS_FIELD_SATELLITE_USED_LEN 20 #define MAVLINK_MSG_GPS_STATUS_FIELD_SATELLITE_ELEVATION_LEN 20 #define MAVLINK_MSG_GPS_STATUS_FIELD_SATELLITE_AZIMUTH_LEN 20 #define MAVLINK_MSG_GPS_STATUS_FIELD_SATELLITE_SNR_LEN 20 #define MAVLINK_MESSAGE_INFO_GPS_STATUS { \ "GPS_STATUS", \ 6, \ { { "satellites_visible", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_gps_status_t, satellites_visible) }, \ { "satellite_prn", NULL, MAVLINK_TYPE_UINT8_T, 20, 1, offsetof(mavlink_gps_status_t, satellite_prn) }, \ { "satellite_used", NULL, MAVLINK_TYPE_UINT8_T, 20, 21, offsetof(mavlink_gps_status_t, satellite_used) }, \ { "satellite_elevation", NULL, MAVLINK_TYPE_UINT8_T, 20, 41, offsetof(mavlink_gps_status_t, satellite_elevation) }, \ { "satellite_azimuth", NULL, MAVLINK_TYPE_UINT8_T, 20, 61, offsetof(mavlink_gps_status_t, satellite_azimuth) }, \ { "satellite_snr", NULL, MAVLINK_TYPE_UINT8_T, 20, 81, offsetof(mavlink_gps_status_t, satellite_snr) }, \ } \ } /** * @brief Pack a gps_status message * @param system_id ID of this system * @param component_id ID of this component (e.g. 200 for IMU) * @param msg The MAVLink message to compress the data into * * @param satellites_visible Number of satellites visible * @param satellite_prn Global satellite ID * @param satellite_used 0: Satellite not used, 1: used for localization * @param satellite_elevation Elevation (0: right on top of receiver, 90: on the horizon) of satellite * @param satellite_azimuth Direction of satellite, 0: 0 deg, 255: 360 deg. * @param satellite_snr Signal to noise ratio of satellite * @return length of the message in bytes (excluding serial stream start sign) */ uint16_t mavlink_msg_gps_status_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, uint8_t satellites_visible, const uint8_t *satellite_prn, const uint8_t *satellite_used, const uint8_t *satellite_elevation, const uint8_t *satellite_azimuth, const uint8_t *satellite_snr); uint16_t mavlink_msg_gps_status_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, uint8_t satellites_visible,const uint8_t *satellite_prn,const uint8_t *satellite_used,const uint8_t *satellite_elevation,const uint8_t *satellite_azimuth,const uint8_t *satellite_snr); uint16_t mavlink_msg_gps_status_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_gps_status_t* gps_status); uint16_t mavlink_msg_gps_status_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_gps_status_t* gps_status); #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS void mavlink_msg_gps_status_send(mavlink_channel_t chan, uint8_t satellites_visible, const uint8_t *satellite_prn, const uint8_t *satellite_used, const uint8_t *satellite_elevation, const uint8_t *satellite_azimuth, const uint8_t *satellite_snr); #if MAVLINK_MSG_ID_GPS_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN void mavlink_msg_gps_status_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan, uint8_t satellites_visible, const uint8_t *satellite_prn, const uint8_t *satellite_used, const uint8_t *satellite_elevation, const uint8_t *satellite_azimuth, const uint8_t *satellite_snr); #endif #endif // MESSAGE GPS_STATUS UNPACKING uint8_t mavlink_msg_gps_status_get_satellites_visible(const mavlink_message_t* msg); uint16_t mavlink_msg_gps_status_get_satellite_prn(const mavlink_message_t* msg, uint8_t *satellite_prn); uint16_t mavlink_msg_gps_status_get_satellite_used(const mavlink_message_t* msg, uint8_t *satellite_used); uint16_t mavlink_msg_gps_status_get_satellite_elevation(const mavlink_message_t* msg, uint8_t *satellite_elevation); uint16_t mavlink_msg_gps_status_get_satellite_azimuth(const mavlink_message_t* msg, uint8_t *satellite_azimuth); uint16_t mavlink_msg_gps_status_get_satellite_snr(const mavlink_message_t* msg, uint8_t *satellite_snr); void mavlink_msg_gps_status_decode(const mavlink_message_t* msg, mavlink_gps_status_t* gps_status); #endif /*_xx_h_*/

golaced@163.com

0607cf2828108a7cebc58f556610ed3b27a33c22

3636d82c2e754fbd60c6e1b48387165ecde79726

/C_Plus/Learning_C/NUMTST.C

6df0e709e530d52dc0ea6a0a9ae46109b8b0a1db

permissive

MCLifeLeader/MiscProjects

2762fa69ea55a91cc668e7be7e29b178ed6fa6c1

335d7dc0f5819e4aff19860a71d65653aecee2d6

refs/heads/master

UTF-8

C

c

#include "stdio.h" main() { int s, w, x, y, z; unsigned char inpt; w = 0; do { w++; if(w>=255) { w = 0; } inpt = w; printf("%d\n", inpt); x = ((w+x+y)/3)+z; inpt = x; printf("%d\n", inpt); y = ((w+x+y)/3)+x; inpt = y; printf("%d\n", inpt); z = ((w+x+y)/3)+y; inpt = z; printf("%d\n", inpt); } while(s != 1); }

kb7ppb@hotmail.com

89426255b0ddd889d9ebfac0aa89ef5284842875

3523b5bae2f818f65275d73780c0bb69f8640249

/hmcu_timer.h

c63ca16aa6af30b5afee5ed93c25e9c63f249089

no_license

LucianaMarques/soft_timer

7ebd2fee22f54641edd6357e22fca0cad7a15d97

b4b354dd8e7e6670d28bf1d9369d5781fb64e658

refs/heads/master

UTF-8

C

h

/** * @file hmcu_timer.h * * @brief Hypothetical MCU Timer register addresses and IRQ handler. */ #ifndef __HMCU_TIMER_H__ #define __HMCU_TIMER_H__ #include <stdio.h> #include <stdint.h> #include <stdbool.h> /***************************************************************************** * Timer clock frequency. *****************************************************************************/ #define TIMER_CLK_HZ (1000) /***************************************************************************** * Timer register addresses. *****************************************************************************/ #define TIMER_CTRL_REG_ADDR (&timer_ctrl) #define TIMER_CNT_REG_ADDR (&timer_cnt) #define TIMER_RLD_REG_ADDR (&timer_rld) /***************************************************************************** * Timer IRQ handler prototype. *****************************************************************************/ /** * @brief Timeout IRQ handler. * * @details This function will be called by our hypothetical MCU interrupt * vector when timer countdown reaches zero. */ void hmcu_timer_irq_handler(void); /***************************************************************************** * For test purposes: variables abstracting hypothetical MCU registers. *****************************************************************************/ extern uint16_t timer_ctrl; extern uint16_t timer_cnt; extern uint16_t timer_rld; #endif /** __HMCU_TIMER_H__ */

lucianadacostamarques@gmail.com

224de462e5906a73e4333232f3c940cdba1b2130

4dcf7947fabb231588487532c067c38b822871a8

/cw04/zad4/zad4b/sender.c

881d435bf1db2246d6c4d2ffd1ba24538f84668b

no_license

PKopel/Unix-Linux-programming

7152422594f8ae20c17b7385b1061738ce48860e

9c4692f40cbdf21ed65d8c1e7d2d27b7ac307184

refs/heads/master

UTF-8

C

c

#define _XOPEN_SOURCE 700 #include <unistd.h> #include <stdlib.h> #include <stdio.h> #include <signal.h> #include <string.h> int counter = 0; pid_t catcher = -1; void (*send)(int); int sig1,sig2,confirmation = 0; void handler(int sig, siginfo_t *info, void *ucontext){ if(sig == sig1){ if(info->si_value.sival_int) printf("sender received %d-th sig1\n",info->si_value.sival_int); if(!confirmation) counter++; } else if(sig == sig2){ printf("sender: %d sig1\n",counter); counter = -1; exit(0); } confirmation = 0; return; } void send_kill(int num){ for (int i = 0; i < num; i++){ sigset_t new_mask; sigfillset(&new_mask); sigdelset(&new_mask,SIGUSR1); confirmation = 1; kill(catcher,sig1); sigsuspend(&new_mask); } kill(catcher,sig2); } void send_queue(int num){ union sigval number; for (int i = 0; i < num; i++){ number.sival_int = i+1; sigset_t new_mask; sigfillset(&new_mask); sigdelset(&new_mask,SIGUSR1); confirmation = 1; sigqueue(catcher,sig1,number); sigsuspend(&new_mask); } number.sival_int = -1; sigqueue(catcher,sig2,number); } int main(int argc, char** argv){ if(argc != 4) return 22; catcher = atoi(argv[1]); int num = atoi(argv[2]); if(strcmp(argv[3],"KILL") == 0){ send = send_kill; sig1 = SIGUSR1; sig2 = SIGUSR2; } else if (strcmp(argv[3],"SIGQUEUE") == 0){ send = send_queue; sig1 = SIGUSR1; sig2 = SIGUSR2; } else if (strcmp(argv[3],"SIGRT") == 0){ send = send_kill; sig1 = SIGRTMIN; sig2 = SIGRTMIN+1; } else return 22; struct sigaction new_action; new_action.sa_sigaction = handler; sigfillset(&new_action.sa_mask); new_action.sa_flags = SA_SIGINFO; if(sigaction(sig1, &new_action, NULL) < 0) printf("can't catch %d\n",sig1); if(sigaction(sig2, &new_action, NULL) < 0) printf("can't catch %d\n",sig2); if(sigaction(SIGUSR1, &new_action, NULL) < 0) printf("can't catch SIGUSR1\n"); sigset_t mask; sigfillset(&mask); sigdelset(&mask,sig1); sigdelset(&mask,sig2); sigprocmask(SIG_SETMASK,&mask,NULL); send(num); while(counter >= 0){ pause(); } return 0; }

pawel.kopel2@gmail.com

ead92b80700b8e7be1df60ae3c6d85de32e8d348

bb45f01aa5b26d4c7640528eacbd39932bdfca13

/applications/rmsd/src/server/server.c

18417afac4b5055c54ce54736be95ac306c6ee2f

no_license

BGCX067/f2f-hg-to-git

f8d17ecc95a0b72eb67505db96216a24d5d477e1

4655aa5d6983c0c8716f3ad9e8ca0b6805a67d30

refs/heads/master

UTF-8

C

c

/* server.c: Copyright (C) 2011 Martin Ramiro Gioiosa, FuDePAN This file is part of the F2F project. F2F is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. F2F is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with F2F. If not, see <http://www.gnu.org/licenses/>. NOTE: This file is in prototype stage, and is under active development. */ #include <stdio.h> #include <string.h> #include <sys/socket.h> #include <errno.h> #include <netinet/in.h> #include <unistd.h> #include <stdlib.h> /**** OWN HEADERS ****************************/ #include "arithmetic.h" #include "communication.h" #include "types.h" #include "endianTool.h" #include "socketTool.h" #include "rmsdCalc.h" /*********************************************/ static void process_packet(BufferClient* inpacket, BufferServer* outpacket) { const size_t sizeOfStructures = inpacket->numberOfCoords * 3 * sizeof(FloatType); char* pointer_first_element = inpacket->data; char* pointer_last_element = inpacket->data + sizeOfStructures * (inpacket->numberOfStructs - 1); FloatType* pointer_results = (FloatType*)outpacket->data; size_t numberOfResults = 0; char* it1; for (it1 = pointer_first_element; it1 < pointer_last_element; it1 += sizeOfStructures) { char* it2; for (it2 = it1 + sizeOfStructures; it2 <= pointer_last_element; it2 += sizeOfStructures) { *pointer_results = rmsd_to((Coord3d*)it1, (Coord3d*)it2, inpacket->numberOfCoords); ++pointer_results; ++numberOfResults; } } outpacket->numberOfResults = numberOfResults; } int main(void) { const int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP); if (sock == -1) { printf ("Error creating socket\n"); exit(EXIT_FAILURE); } struct sockaddr_in sa; sa.sin_family = AF_INET; sa.sin_addr.s_addr = INADDR_ANY; sa.sin_port = htons(PORT); socklen_t address_len = sizeof(sa); const int b = bind(sock, (struct sockaddr*)&sa, sizeof(sa)); if (b == -1) { printf("Error bind failed\n"); close(sock); exit(EXIT_FAILURE); } /* PREPARE FOR INCOMING CONNECTION */ const int list = listen(sock, 1); if (list == -1) { printf("Error list failed\n"); close(sock); exit(EXIT_FAILURE); } /***********************************/ BufferClient buffer_in; BufferServer buffer_out; while (1) { /* WAIT FOR CONNECT CLIENT */ printf ("Waiting for client...\n"); const int sock_client = accept(sock, (struct sockaddr*)&sa, &address_len); if (sock_client == -1) { printf("Error accepting client\n"); } /***************************/ /* WAIT TO RECEIVE A PACKET */ const int read = read_socket(sock_client, (char*)&buffer_in, LENGHT_BUFFER); if (read == -1) { printf("Error receiving packet\n"); } /****************************/ /* CONVERT */ endian_buffer_client(&buffer_in, networkToHost); /***********/ /* PROCESS THE PACKET */ process_packet(&buffer_in, &buffer_out); /**********************/ /* CONVERT */ endian_buffer_server(&buffer_out, hostToNetwork); /***********/ /* SEND RESULTS */ const int write = write_socket(sock_client, (char*)&buffer_out, LENGHT_BUFFER); if (write == -1) { printf("Error sending packet\n"); } /****************/ /* END OF COMMUNICATION */ const int shutdn = shutdown(sock_client, SHUT_RDWR); if (shutdn == -1) { printf("Error shutting down\n"); } /****************/ } return EXIT_SUCCESS; }

giomartinr@gmail.com

f75c64978f23f2c316c808a60473f85d8c575085

7e41f5263395d119d4fba880fa05022d58324ca5

/liblinear-2.1/predict.c

1b5c54715ff1f9cef62a303ce02089bd4f69c392

permissive

moulygupta23/MCM-mtp

93b95a9ed357840eb48a24577d50cf63b1d73242

1713e5a84d9269902ae8792d71e6e995c0503c83

refs/heads/master

UTF-8

C

c

#include <stdio.h> #include <ctype.h> #include <stdlib.h> #include <string.h> #include <errno.h> #include "linear.h" int print_null(const char *s,...) {return 0;} static int (*info)(const char *fmt,...) = &printf; struct feature_node *x; int max_nr_attr = 64; struct model* model_; int flag_predict_probability=0; void exit_input_error(int line_num) { fprintf(stderr,"Wrong input format at line %d\n", line_num); exit(1); } static char *line = NULL; static int max_line_len; static char* readline(FILE *input) { int len; if(fgets(line,max_line_len,input) == NULL) return NULL; while(strrchr(line,'\n') == NULL) { max_line_len *= 2; line = (char *) realloc(line,max_line_len); len = (int) strlen(line); if(fgets(line+len,max_line_len-len,input) == NULL) break; } return line; } void do_predict(FILE *input, FILE *output) { int correct = 0; int total = 0; double error = 0; double sump = 0, sumt = 0, sumpp = 0, sumtt = 0, sumpt = 0; int nr_class=get_nr_class(model_); double *prob_estimates=NULL; int j, n; int nr_feature=get_nr_feature(model_); if(model_->bias>=0) n=nr_feature+1; else n=nr_feature; if(flag_predict_probability) { int *labels; if(!check_probability_model(model_)) { fprintf(stderr, "probability output is only supported for logistic regression\n"); exit(1); } labels=(int *) malloc(nr_class*sizeof(int)); get_labels(model_,labels); prob_estimates = (double *) malloc(nr_class*sizeof(double)); fprintf(output,"labels"); for(j=0;j<nr_class;j++) fprintf(output," %d",labels[j]); fprintf(output,"\n"); free(labels); } max_line_len = 1024; line = (char *)malloc(max_line_len*sizeof(char)); while(readline(input) != NULL) { int i = 0; double target_label, predict_label; char *idx, *val, *label, *endptr; int inst_max_index = 0; // strtol gives 0 if wrong format label = strtok(line," \t\n"); if(label == NULL) // empty line exit_input_error(total+1); target_label = strtod(label,&endptr); if(endptr == label || *endptr != '\0') exit_input_error(total+1); while(1) { if(i>=max_nr_attr-2) // need one more for index = -1 { max_nr_attr *= 2; x = (struct feature_node *) realloc(x,max_nr_attr*sizeof(struct feature_node)); } idx = strtok(NULL,":"); val = strtok(NULL," \t"); if(val == NULL) break; errno = 0; x[i].index = (int) strtol(idx,&endptr,10); if(endptr == idx || errno != 0 || *endptr != '\0' || x[i].index <= inst_max_index) exit_input_error(total+1); else inst_max_index = x[i].index; errno = 0; x[i].value = strtod(val,&endptr); if(endptr == val || errno != 0 || (*endptr != '\0' && !isspace(*endptr))) exit_input_error(total+1); // feature indices larger than those in training are not used if(x[i].index <= nr_feature) ++i; } if(model_->bias>=0) { x[i].index = n; x[i].value = model_->bias; i++; } x[i].index = -1; if(flag_predict_probability) { int j; predict_label = predict_probability(model_,x,prob_estimates); fprintf(output,"%g",predict_label); for(j=0;j<model_->nr_class;j++) fprintf(output," %g",prob_estimates[j]); fprintf(output,"\n"); } else { predict_label = predict(model_,x); fprintf(output,"%g\n",predict_label); } if(predict_label == target_label) ++correct; error += (predict_label-target_label)*(predict_label-target_label); sump += predict_label; sumt += target_label; sumpp += predict_label*predict_label; sumtt += target_label*target_label; sumpt += predict_label*target_label; ++total; } if(check_regression_model(model_)) { info("Mean squared error = %g (regression)\n",error/total); info("Squared correlation coefficient = %g (regression)\n", ((total*sumpt-sump*sumt)*(total*sumpt-sump*sumt))/ ((total*sumpp-sump*sump)*(total*sumtt-sumt*sumt)) ); } else info("Accuracy = %g%% (%d/%d)\n",(double) correct/total*100,correct,total); if(flag_predict_probability) free(prob_estimates); } void exit_with_help() { printf( "Usage: predict [options] test_file model_file output_file\n" "options:\n" "-b probability_estimates: whether to output probability estimates, 0 or 1 (default 0); currently for logistic regression only\n" "-q : quiet mode (no outputs)\n" ); exit(1); } int main(int argc, char **argv) { FILE *input, *output; int i; // parse options for(i=1;i<argc;i++) { if(argv[i][0] != '-') break; ++i; switch(argv[i-1][1]) { case 'b': flag_predict_probability = atoi(argv[i]); break; case 'q': info = &print_null; i--; break; default: fprintf(stderr,"unknown option: -%c\n", argv[i-1][1]); exit_with_help(); break; } } if(i>=argc) exit_with_help(); input = fopen(argv[i],"r"); if(input == NULL) { fprintf(stderr,"can't open input file %s\n",argv[i]); exit(1); } output = fopen(argv[i+2],"w"); if(output == NULL) { fprintf(stderr,"can't open output file %s\n",argv[i+2]); exit(1); } if((model_=load_model(argv[i+1]))==0) { fprintf(stderr,"can't open model file %s\n",argv[i+1]); exit(1); } x = (struct feature_node *) malloc(max_nr_attr*sizeof(struct feature_node)); do_predict(input, output); free_and_destroy_model(&model_); free(line); free(x); fclose(input); fclose(output); return 0; }

moulygupta23@gmail.com

382cdb2c263ecef7ace773b52519020028485ccd

8d66da22764e44dd5680a5ce4bdf165f1546c25e

/Firmware_F411 V1.2/COMMUNICATE/src/radiolink.c

a02d2abcbe136ebfef46847029748e4002200d30

no_license

xindong324/MiniFly

679210b8f00d7f2bac73470ffbb62d5718e9c2a9

21c0679563510728590a306e627fbeeb42a4cdd3

refs/heads/master

GB18030

C

c

#include <string.h> #include "config.h" #include "radiolink.h" #include "config_param.h" #include "led.h" #include "ledseq.h" #include "uart_syslink.h" /*FreeRtos includes*/ #include "FreeRTOS.h" #include "task.h" #include "semphr.h" #include "queue.h" /******************************************************************************** * 本程序只供学习使用，未经作者许可，不得用于其它任何用途 * ALIENTEK MiniFly * 无线通信驱动代码 * 正点原子@ALIENTEK * 技术论坛:www.openedv.com * 创建日期:2018/6/22 * 版本：V1.2 * 版权所有，盗版必究。 * Copyright(C) 广州市星翼电子科技有限公司 2014-2024 * All rights reserved ********************************************************************************/ #define RADIOLINK_TX_QUEUE_SIZE 30 /*接收队列个数*/ static enum { waitForStartByte1, waitForStartByte2, waitForMsgID, waitForDataLength, waitForData, waitForChksum1, }rxState; static bool isInit; static atkp_t txPacket; static atkp_t rxPacket; static xQueueHandle txQueue; static void atkpPacketDispatch(atkp_t *rxPacket); //radiolink接收ATKPPacket任务 void radiolinkTask(void *param) { rxState = waitForStartByte1; u8 c; u8 dataIndex = 0; u8 cksum = 0; while(1) { if (uartslkGetDataWithTimout(&c)) { switch(rxState) { case waitForStartByte1: rxState = (c == DOWN_BYTE1) ? waitForStartByte2 : waitForStartByte1; cksum = c; break; case waitForStartByte2: rxState = (c == DOWN_BYTE2) ? waitForMsgID : waitForStartByte1; cksum += c; break; case waitForMsgID: rxPacket.msgID = c; rxState = waitForDataLength; cksum += c; break; case waitForDataLength: if (c <= ATKP_MAX_DATA_SIZE) { rxPacket.dataLen = c; dataIndex = 0; rxState = (c > 0) ? waitForData : waitForChksum1; /*c=0,数据长度为0，校验1*/ cksum += c; } else { rxState = waitForStartByte1; } break; case waitForData: rxPacket.data[dataIndex] = c; dataIndex++; cksum += c; if (dataIndex == rxPacket.dataLen) { rxState = waitForChksum1; } break; case waitForChksum1: if (cksum == c) /*所有校验正确*/ { atkpPacketDispatch(&rxPacket); } else /*校验错误*/ { rxState = waitForStartByte1; IF_DEBUG_ASSERT(1); } rxState = waitForStartByte1; break; default: ASSERT(0); break; } } else /*超时处理*/ { rxState = waitForStartByte1; } } } void radiolinkInit(void) { if (isInit) return; uartslkInit(); /*创建发送队列，CRTP_TX_QUEUE_SIZE个消息*/ txQueue = xQueueCreate(RADIOLINK_TX_QUEUE_SIZE, sizeof(atkp_t)); ASSERT(txQueue); isInit = true; } /*打包ATKPPacket数据通过串口DMA发送*/ static void uartSendPacket(atkp_t *p) { int dataSize; u8 cksum = 0; u8 sendBuffer[36]; ASSERT(p->dataLen <= ATKP_MAX_DATA_SIZE); sendBuffer[0] = UP_BYTE1; sendBuffer[1] = UP_BYTE2; sendBuffer[2] = p->msgID; sendBuffer[3] = p->dataLen; memcpy(&sendBuffer[4], p->data, p->dataLen); dataSize = p->dataLen + 5;//加上cksum /*计算校验和*/ for (int i=0; i<dataSize-1; i++) { cksum += sendBuffer[i]; } sendBuffer[dataSize-1] = cksum; /*串口DMA发送*/ uartslkSendDataDmaBlocking(dataSize, sendBuffer); } /*radiolink接收到ATKPPacket预处理*/ static void atkpPacketDispatch(atkp_t *rxPacket) { atkpReceivePacketBlocking(rxPacket); if( rxPacket->msgID == DOWN_POWER) {;}/*do noting*/ else { ledseqRun(DATA_RX_LED, seq_linkup); /*接收到一个遥控无线数据包则发送一个包*/ if(xQueueReceive(txQueue, &txPacket, 0) == pdTRUE) { ASSERT(txPacket.dataLen <= ATKP_MAX_DATA_SIZE); ledseqRun(DATA_TX_LED, seq_linkup); uartSendPacket(&txPacket); } } } bool radiolinkSendPacket(const atkp_t *p) { ASSERT(p); ASSERT(p->dataLen <= ATKP_MAX_DATA_SIZE); return xQueueSend(txQueue, p, 0); } bool radiolinkSendPacketBlocking(const atkp_t *p) { ASSERT(p); ASSERT(p->dataLen <= ATKP_MAX_DATA_SIZE); return xQueueSend(txQueue, p, portMAX_DELAY); } //获取剩余可用txQueue个数 int radiolinkGetFreeTxQueuePackets(void) { return (RADIOLINK_TX_QUEUE_SIZE - uxQueueMessagesWaiting(txQueue)); }

xindong324@163.com

cdddeacb82da25ccb2e46fdfcbd46150dc6d8dfb

fe5e5f3e3da1d6199da2161fa4ee1b8516009894

/Midterm_C/Problem3_20/Problem3_20/main.c

a6bd508fdbe30ff284a36adcb13e6449fbf22eac

no_license

alien-house/C

4a4d2f8ebbd2e6a86ae8e1050c2f87fd3a9f57bc

5c9c9e70580a328b761a02bbcd5c2da17c8d8a59

refs/heads/master

UTF-8

C

c

// // main.c // Problem3_20 // // Created by sin on 2017/01/28. // Copyright © 2017年 shinji. All rights reserved. // #include <stdio.h> int main(int argc, const char * argv[]) { int a[3] = {1, 2, 3}; int *p = a; int **r = &p; printf("%p \n", a); printf("%d \n", *p); printf("%p \n", p); printf("%d \n", **r); printf("%p \n", &p); printf("%p \n", p); printf("%p \n", r); printf("%p %p", *r, a); return 0; }

info@alien-house.com

f61efdf3e7d13023c1dcd7a6b0b33646224ba264

f3a5d435414b7389f0e3ac72f2ccd28d7a4911e4

/src/mx_print.c

3f3dfb9c5121474cb4b2da1354183877319564b2

no_license

zeromotivat1on/ush

1a794c7abd8c7bd8ebc8ed8bc56e8f0527108110

cfae0103030163ce9fc409a6cc3f4a6f105387a2

refs/heads/master

UTF-8

C

c

#include "ush.h" void mx_print_color(char *macros, char *str) { mx_printstr(macros); mx_printstr(str); mx_printstr(RESET); } void mx_print_strarr_in_line(char **result, const char *delim) { if (!result || !delim) { return; } if (result[0] == NULL) { mx_printstr("NULL\n"); } for (int i = 0; result[i]; i++) { mx_printstr(result[i]); mx_printstr(delim); if (result[i + 1] == NULL){ mx_printstr("NULL\n"); } } } bool mx_parse_error(char *str, int k) { mx_printerr("ush: parse error near `"); write(2, str, k); mx_printerr("\'\n"); return true; } bool mx_unmached_error(char c) { if (c == '\"' || c == '\'') { mx_printerr("Odd number of quotes.\n"); return true; } else { mx_printerr("Unmatched "); write(2, &c, 1); mx_printerr(".\n"); return true; } } char *mx_syntax_error(char *str) { mx_printerr("ush: syntax error near unexpected token `"); mx_printerr(str); mx_printerr("'\n"); return NULL; } static char *get_delim_from_type(int t) { if (t == SEP) { return mx_strdup(";"); } else if (t == FON) { return mx_strdup("&"); } else if (t == R_OUTPUT) { return mx_strdup(">"); } else if (t == OR) { return mx_strdup("||"); } else if (t == AND) { return mx_strdup("&&"); } else if (t == PIPE) { return mx_strdup("|"); } else if (t == R_INPUT) { return mx_strdup("<"); } else if (t == R_OUTPUT_DBL) { return mx_strdup(">>"); } else if (t == R_INPUT_DBL) { return mx_strdup("<<"); } return NULL; } Abstract *mx_parse_error_ush(int t, Abstract *ast_res, char *str) { char *delim; if (t != SEP) { delim = get_delim_from_type(t); mx_printerr("ush: parse error near `"); write(2, delim, mx_strlen(delim)); mx_strdel(&delim); mx_printerr("\'\n"); } mx_ast_clear_list(&ast_res); mx_strdel(&str); return NULL; } static void print_all(char *command, char *error, char arg) { mx_printerr("ush: "); mx_printerr(command); mx_printerr(": -"); mx_printerr(&arg); mx_printerr(": invalid option\n"); mx_printerr(command); mx_printerr(": usage: "); mx_printerr(command); mx_printerr(error); mx_printerr(" \n"); } int mx_count_options(char **args, char *options, char *command, char *error) { int n_options = 0; for (int i = 1; args[i] != NULL; i++) { if (args[i][0] != '-' || strcmp(args[i], "-") == 0) break; if (strcmp(args[i], "--") == 0) { n_options++; break; } for (int j = 1; j < mx_strlen(args[i]); j++) { if(mx_get_char_index(options,args[i][j]) < 0) { print_all(command, error, args[i][j]); return -1; } } n_options++; } return n_options; } static void print_left(Abstract *q) { for (Abstract *tmp_left = q->left; tmp_left; tmp_left = tmp_left->next) { mx_printstr("redir == "); if (tmp_left->type == R_INPUT) mx_printstr("< "); else if (tmp_left->type == R_INPUT_DBL) mx_printstr("<< "); else if (tmp_left->type == R_OUTPUT) mx_printstr("> "); else if (tmp_left->type == R_OUTPUT_DBL) mx_printstr(">> "); if (tmp_left->args) mx_print_strarr_in_line(tmp_left->args, " "); else if (tmp_left->token) { mx_printstr(q->token); mx_printstr("\n"); } } } static void print_list(Abstract *parsed_line) { for (Abstract *q = parsed_line; q; q = q->next) { mx_printstr("proc == "); if (q->args) mx_print_strarr_in_line(q->args, " "); else if (q->token) { mx_printstr(q->token); mx_printstr("\n"); } if (q->left) print_left(q); mx_printstr("delim == "); mx_printint(q->type); mx_printstr("\n"); } } void mx_ast_print(Abstract **ast) { char *tmp = NULL; for (int i = 0; ast[i]; i++) { mx_print_color(MX_YEL, "job-"); tmp = mx_itoa(i + 1); mx_print_color(MX_YEL, tmp); mx_strdel(&tmp); mx_printstr("\n"); print_list(ast[i]); } mx_print_color(MX_YEL, "-----\n"); }

lyannoy.alexander@gmail.com

723e17d307a937d2a0b8fbcd4834e76b8bde5d40

91ddd17e771f99cd4eb5acec6e9127f2acb833d6

/C-algorithm/ProgrammingPearls/maxSumOfSubsequence/maxSequence_2.c

cee643333950f4be8a7377b4eb28008f864a6184

no_license

jabc1/ProgramLearning

8a5a7d174e9cf6b1d0672704effa8c320380442e

90684a7f5fa76b784375b258658396c9f23f2314

refs/heads/master

UTF-8

C

c

/** 最大子序列求和 时间复杂度：O(n^2) */ int maxSequence(int *arr, int n){ int maxSum = 0; int currentSum = 0; for (int i = 0; i < n; i++){ currentSum = 0; for (int j = i; j < n; j++){ // 必须有等于号 currentSum += arr[j]; if (maxSum < currentSum){ maxSum = currentSum; } } } return maxSum; } /********************** 第二种方法 *********************/ int maxSequence(int *arr, int n){ if (arr == NULL || n < 1){ return -1; // invalid arguments } int *cumarr = (int *)malloc(n * sizeof(int)); cumarr[0] = arr[0]; for (int i = 1; i < n; i++){ cumarr[i] = cumarr[i-1] + arr[i]; } // partial_sum int maxSum = arr[0]; int currentSum = 0; for (int i = 0; i < n; i++){ for (int j = i; j < n; j++){ if (i == 0){ currentSum = cumarr[j] - 0; } else{ currentSum = cumarr[j] - cumarr[i-1]; } if (maxSum < currentSum){ maxSum = currentSum; } } } return maxSum; }

ywangsh2014@sina.com

8f07dbee6914ea966e7a17f9c878dde87d7c257f

5bcbe7af06d0e47fa8c95041639e5b43f22e153a

/usr/tools/wpm/conf.h

d9183fd840d633462ff253bf681c41a7af28c061

no_license

hongbochen/OS-Zero

d19a84591718fe95b622a60ba5578e70853954a5

a636f512fe31626b6aa463c0f7a635167dee951a

refs/heads/master

UTF-8

C

h

#ifndef __WPM_CONF_H__ #define __WPM_CONF_H__ #define WPMPREWARM 1 #define WPMVECFULL 0 #define WPMPROF 1 #define WPMVEC 0 #define PTHREAD 1 #define WPMDB 0 #define WPMDEBUG 0 #define WPMTRACE 0 #define ZASDB 0 #define WPMWORDSIZE 32 #endif /* __WPM_CONF_H__ */

tuomoster@gmail.com

44759bdeaa2eda0de230f4b81e3d7455c8e36d0c

a5bb874436a5238fc94e13ad900e6107dad92330

/examples/eeprom/eeprom-test.c

e543d4feaf3fe6a5c3382d763557ebe23c602a96

no_license

nikhilpnarang/sprinkio-atmel-firmware

683f1865a7c192738b33db531424b17ab929c4dc

4edec2d823e12ada7248e25d364a5ea382c87b30

refs/heads/master

UTF-8

C

c

#include "../../sprinkio.h" uint8_t EEMEM testInteger = 30; int main() { uint8_t SRAMchar = eeprom_read_byte(&testInteger); _delay_ms(1000); // allow time for data transfer sei(); // enable global interrupts usart_init(); // enable usart connections write_rs232_s("\r\nRandom Variable: "); write_rs232_int(SRAMchar); _delay_ms(1000); return 0; }

nikhilnarang@Nikhils-MacBook.local

f234d2a5cd7973325b8c1b57ee1768a11488a6c2

ff68c5e9516bba84ad4398e0094f0385ec738661

/hq_source_code/013_test_rd_wr/rd_wr.c

dad377ae0cd255d9bf5fe101a434cd65215868ee

no_license

007skyfall/itop_4412_driver

28e889fb3feaa0248b976c45e3729b2c6e5e359c

8c19cfac84ea9573fdcff16b068355e8030277b0

refs/heads/master

GB18030

C

c

#include <linux/init.h> #include <linux/module.h> #include <linux/kernel.h> #include <linux/cdev.h> #include <linux/fs.h> #include <linux/errno.h> #include <asm/uaccess.h> #define NAME "rd_wr_demo" #define MAX 64 char ker_buf[MAX] = {0}; /* 1.模块三要素 2.字符框架相关 2.1 申请设备号 2.2 cdev申请 2.3 cdev初始化 2.4 cdev注册 */ ssize_t demo_read(struct file *file, char __user *user, size_t size, loff_t *loff) { if(size > MAX) size = MAX; //unsigned long copy_to_user(void *to, const void __user *from, unsigned long n) if(raw_copy_to_user(user,ker_buf,size)){ printk("copy_to_user fail...%s,%d\n",__func__,__LINE__); return -EAGAIN; } printk("%s,%d\n",__func__,__LINE__); return size; } ssize_t demo_write(struct file *file, const char __user *user ,size_t size, loff_t *loff) { if(size > MAX) size = MAX; //unsigned long copy_from_user(void *to, const void __user *from, unsigned long n) if(raw_copy_from_user(ker_buf,user,size)){ printk("copy_from_user fail...%s,%d\n",__func__,__LINE__); return -EAGAIN; } printk("%s,%d\n",__func__,__LINE__); return size; } int demo_open (struct inode *inode, struct file *file) { printk("%s,%d\n",__func__,__LINE__); return 0; } int demo_close (struct inode *inode, struct file *file) { printk("%s,%d\n",__func__,__LINE__); return 0; } int major = 0 , minor = 0; struct file_operations f_ops = { .owner = THIS_MODULE, .open = demo_open, .release = demo_close, .read = demo_read, .write = demo_write, }; int __init demo_init(void) { major = register_chrdev(major,NAME,&f_ops); if(major < 0){ printk("register_chrdev fail ...%s,%d\n",__func__,__LINE__); return -EINVAL; } printk("major :%d \t %s,%d\n",major ,__func__,__LINE__); return 0; } void __exit demo_exit(void) { unregister_chrdev(major,NAME); printk("%s,%d\n",__func__,__LINE__); } module_init(demo_init); module_exit(demo_exit); MODULE_LICENSE("GPL");

565911459@qq.com

d45f88e7cfdd51b0c9e171c4a2258fa03e959458

f7ff15d6f0eaf897d9ed9918544d68e3ed2f3c6b

/set2prgm19.c

c14bb997aad77dcd21a606c4af6bfabe1792e684

no_license

SUBHAPRANAV/c

4912899a966a677677976241c9d10e702fc1fa30

91b7bbc72a331cfbfa6bf4346eb243588e25f082

refs/heads/master

UTF-8

C

c

#include<stdio.h> int main() { int a,i,fact=1; scanf("%d",&a); for(i=1;i<=a;i++) { fact=fact*i; } printf("%d",fact); return 0; }

noreply@github.com

e329a6d561f98c7ebb6243011394b7451a6e2b48

7069cb71852cf1a5995133b1858bab3e46b501f9

/source/ekernel/drivers/drv/legacy/deviceman/devices/dev.h

368d04cf99d6cf4e2bdf98d8b8d21bf15c6f04a5

no_license

lindenis-org/lindenis-v833-RTOS-melis-4.0

d2646c7093851d45645679a55bcf1462b8d4d18e

71ab8faeee960e27ef83a9ff2e4ae4b7f33eda20

refs/heads/master

GB18030

C

h

/* ********************************************************************************************************* * ePOS * the Easy Portable/Player Operation System * eMOD sub-system * * (c) Copyright 2006-2007, Steven.ZGJ China * All Rights Reserved * * File : devman_private.h * Version: V1.0 * By : steven.zgj ********************************************************************************************************* */ #ifndef __DEV_H__ #define __DEV_H__ #include <typedef.h> #include <sys_device.h> #define NODETYPE_CLASS 0x00000000 #define NODETYPE_DEV 0x00000001 #define DEV_STAT_INACTIVE 0x00 #define DEV_STAT_ACTIVE 0x01 typedef struct __DEV_NODE __dev_node_t; typedef struct __DEV_CLASSNODE __dev_classnode_t; /* 设备类节点 */ struct __DEV_CLASSNODE { __dev_classnode_t *next; __dev_node_t *nodelist; int nodetype; __u8 usedcnt; char *name; }; /* 设备节点句柄，此句柄用于保存一个设备各种信息的数据结构 */ struct __DEV_NODE { __dev_node_t *next; __dev_classnode_t *classnode; /* 类节点 */ int attrib; char *name; char pletter; __u32 opentimes; /* 句柄打开的次数 */ __u32 status; /* 节点状态：0表示正常，0xff表示为死节点（驱动程序代码已经卸载）*/ __dev_devop_t DevOp; /* 保存设备操作句柄 */ void *pOpenArg; __hdle sem; __hdle hDev; /* 设备句柄 */ }; /* ****************************************************** * 设备节点操作句柄，此句柄用于用户打开一个设备节点时返 * 回的句柄，它不同于设备句柄，它是设备节点的实例，而设 * 备句柄是设备的实例。 ****************************************************** */ typedef struct __DEV_DEV { __dev_node_t *devnode; /* 指向设备节点 */ __hdle hDev; /* 设备句柄，直接从__dev_node_t里copy，以方便使用 */ __dev_devop_t DevOp; /* 设备操作入口，直接从__dev_node_t里copy，以方便使用 */ } __dev_dev_t; #endif //#ifndef __DEV_H__

given@lindeni.com

eb5a3df8f01f18570018bc227655aa5b8ed3b91e

e516aa3fce5fc72bb900de01254f252187252096

/wolf3d.h

cbbe1305f4c2b991932871108261974fa51119cd

no_license

Ggrybova/Wolf3D

fe604a3cf33b5936c775c8998b7e19df603dc77b

10bdfcc85d810c3cc4f27b177ec3600ebaf4dfdb

refs/heads/master

UTF-8

C

h

/* ************************************************************************** */ /* */ /* ::: :::::::: */ /* wolf3d.h :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: ggrybova <marvin@42.fr> +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/07/14 19:26:51 by ggrybova #+# #+# */ /* Updated: 2017/11/14 13:04:22 by ggrybova ### ########.fr */ /* */ /* ************************************************************************** */ #ifndef WOLF3D_H # define WOLF3D_H # define WIDTH 640 # define HEIGHT 480 # include "libft/libft.h" # include "minilibx_macos/mlx.h" # include <math.h> typedef struct s_im { int w; int h; void *im; char *addr; int b_p_p; int size_l; int end; } t_im; typedef struct s_col { int red; int green; int blue; int c; } t_col; typedef struct s_mlx { void *mlx; void *win; int map_width; int map_height; int map[24][24]; double px; double py; double dx; double dy; double plane_x; double plane_y; double move_speed; double rot_speed; t_im *wall_tex; t_im image; double camera; double ray_px; double ray_py; double ray_dx; double ray_dy; double dside_x; double dside_y; double side_x; double side_y; double wall_dist; int box_x; int box_y; int wall; int side; int step_x; int step_y; int line_height; int y0; int y1; int tex_n; int tex_x; int tex_y; double wall_x; double fl_wall_x; double fl_wall_y; int fl_tex_x; int fl_tex_y; int ray_y; int music; } t_mlx; void fill_map(t_mlx *m); void fill_data(t_mlx *m); int create_labyrinth(t_mlx *m); void get_img_color(t_im *tex, int x, int y, t_col *c); void pixel_coord_img(t_im *img, int x, int y, t_col *c); void draw_wall(t_mlx *m, int x); void draw_floor_and_ceil(t_mlx *m, int x); int hook_func(int key, t_mlx *m); void *mlx_init(); int hook_func2(t_mlx *m); #endif

ggrybova@e3r5p9.unit.ua

1f154d18b755c958e9de32cd576abca2612694f0

76e7239d2090d861aad90fe25c5fb34860aa5d18

/src/github.com/moovweb/gokogiri/xml/helper.h

6dbde9ad5a8151470276dc2c771a18bcf3a1ade7

permissive

codygman/movie-availability-api

085f421820412c7adfdf00c75aecd9057a705855

e998765466bc59cb558cedcffc31a1e875a8038b

refs/heads/master

UTF-8

C

h

#ifndef __CHELPER_H__ #define __CHELPER_H__ #include <libxml/tree.h> #include <libxml/parser.h> #include <libxml/HTMLtree.h> #include <libxml/HTMLparser.h> #include <libxml/xmlsave.h> #include <libxml/xpath.h> #include <libxml/debugXML.h> xmlDoc* xmlParse(void *buffer, int buffer_len, void *url, void *encoding, int options, void *error_buffer, int errror_buffer_len); xmlNode* xmlParseFragment(void* doc, void *buffer, int buffer_len, void *url, int options, void *error_buffer, int error_buffer_len); xmlNode* xmlParseFragmentAsDoc(void *doc, void *buffer, int buffer_len, void *url, void *encoding, int options, void *error_buffer, int error_buffer_len); int xmlSaveNode(void *wbuffer, void *node, void *encoding, int options); void xmlSetContent(void* node, void *content); xmlDoc* newEmptyXmlDoc(); xmlElementType getNodeType(xmlNode *node); char *xmlDocDumpToString(xmlDoc *doc, void *encoding, int format); char *htmlDocDumpToString(xmlDoc *doc, int format); void xmlFreeChars(char *buffer); int xmlUnlinkNodeWithCheck(xmlNode *node); int xmlNodePtrCheck(void *node); typedef struct XmlBufferContext { void *obj; char *buffer; int buffer_len; int data_size; } XmlBufferContext; #endif //__CHELPER_H__

codygman.consulting@gmail.com

cd2f29d9a3d249ce259828b7c31bc2aacda1a1a9

ca739813905897c93d7b2bdb8866f93f18186060

/001HumidtyMonitor/Core/Src/DHT11.c

51cf855a45100feffbd44f7c88111445a07d4e70

no_license

99003199/CortexM4_Embedded

f007b62f1ceaa6685b4bc078816a664c5a614799

8743fba4f5d3fb0596d79440c2d425ed96a5ca5e

refs/heads/main

UTF-8

C

c

#include "main.h" #include <stdint.h> void Set_Pin_Output (GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin) { GPIO_InitTypeDef GPIO_InitStruct = {0}; GPIO_InitStruct.Pin = GPIO_Pin; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; HAL_GPIO_Init(GPIOx, &GPIO_InitStruct); } void Set_Pin_Input (GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin) { GPIO_InitTypeDef GPIO_InitStruct = {0}; GPIO_InitStruct.Pin = GPIO_Pin; GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; HAL_GPIO_Init(GPIOx, &GPIO_InitStruct); } void DHT11_Start (void) { Set_Pin_Output (dht11_GPIO_Port, dht11_Pin); HAL_GPIO_WritePin (dht11_GPIO_Port, dht11_Pin, DISABLE); delay(18000); HAL_GPIO_WritePin(dht11_GPIO_Port, dht11_Pin, ENABLE); delay(20); Set_Pin_Input(dht11_GPIO_Port, dht11_Pin); } uint8_t DHT11_Check_Response (void) { uint8_t Response = 0; delay (40); if (!(HAL_GPIO_ReadPin (dht11_GPIO_Port, dht11_Pin))) { delay (80); if ((HAL_GPIO_ReadPin (dht11_GPIO_Port, dht11_Pin))) Response = 1; else Response = -1; } while ((HAL_GPIO_ReadPin (dht11_GPIO_Port, dht11_Pin))); return Response; } uint8_t DHT11_Read (void) { uint8_t i,j; for (j=0;j<8;j++) { while (!(HAL_GPIO_ReadPin (dht11_GPIO_Port, dht11_Pin))); delay (40); if (!(HAL_GPIO_ReadPin (dht11_GPIO_Port, dht11_Pin))) { i&= ~(1<<(7-j)); } else { i|= (1<<(7-j)); } while ((HAL_GPIO_ReadPin (dht11_GPIO_Port, dht11_Pin))); } return i; }

amit.das@ltts.com

d1793a3f1aac82f038110473741d9ee6b69982f2

e80e5374b8fd00379293adb35fc8cf017d5f4cc7

/qemu_mode/qemu-2.10.0/hw/ssi/omap_spi.c

22034656b8c8fde4edcdc063372ac98b36d7ee35

permissive

CAFA1/afl

dcebf3a3acae3e9783bbb79d8cff6958b496fa34

01c113b61ab70c3b02f3d7c74e6dfa20cfc7813d

refs/heads/master

Apache-2.0

C

UTF-8

C

c

/* * TI OMAP processor's Multichannel SPI emulation. * * Copyright (C) 2007-2009 Nokia Corporation * * Original code for OMAP2 by Andrzej Zaborowski <andrew@openedhand.com> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 or * (at your option) any later version of the License. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include "qemu/osdep.h" #include "hw/hw.h" #include "hw/arm/omap.h" /* Multichannel SPI */ struct omap_mcspi_s { MemoryRegion iomem; qemu_irq irq; int chnum; uint32_t sysconfig; uint32_t systest; uint32_t irqst; uint32_t irqen; uint32_t wken; uint32_t control; struct omap_mcspi_ch_s { qemu_irq txdrq; qemu_irq rxdrq; uint32_t (*txrx)(void *opaque, uint32_t, int); void *opaque; uint32_t tx; uint32_t rx; uint32_t config; uint32_t status; uint32_t control; } ch[4]; }; static inline void omap_mcspi_interrupt_update(struct omap_mcspi_s *s) { qemu_set_irq(s->irq, s->irqst & s->irqen); } static inline void omap_mcspi_dmarequest_update(struct omap_mcspi_ch_s *ch) { qemu_set_irq(ch->txdrq, (ch->control & 1) && /* EN */ (ch->config & (1 << 14)) && /* DMAW */ (ch->status & (1 << 1)) && /* TXS */ ((ch->config >> 12) & 3) != 1); /* TRM */ qemu_set_irq(ch->rxdrq, (ch->control & 1) && /* EN */ (ch->config & (1 << 15)) && /* DMAW */ (ch->status & (1 << 0)) && /* RXS */ ((ch->config >> 12) & 3) != 2); /* TRM */ } static void omap_mcspi_transfer_run(struct omap_mcspi_s *s, int chnum) { struct omap_mcspi_ch_s *ch = s->ch + chnum; if (!(ch->control & 1)) /* EN */ return; if ((ch->status & (1 << 0)) && /* RXS */ ((ch->config >> 12) & 3) != 2 && /* TRM */ !(ch->config & (1 << 19))) /* TURBO */ goto intr_update; if ((ch->status & (1 << 1)) && /* TXS */ ((ch->config >> 12) & 3) != 1) /* TRM */ goto intr_update; if (!(s->control & 1) || /* SINGLE */ (ch->config & (1 << 20))) { /* FORCE */ if (ch->txrx) ch->rx = ch->txrx(ch->opaque, ch->tx, /* WL */ 1 + (0x1f & (ch->config >> 7))); } ch->tx = 0; ch->status |= 1 << 2; /* EOT */ ch->status |= 1 << 1; /* TXS */ if (((ch->config >> 12) & 3) != 2) /* TRM */ ch->status |= 1 << 0; /* RXS */ intr_update: if ((ch->status & (1 << 0)) && /* RXS */ ((ch->config >> 12) & 3) != 2 && /* TRM */ !(ch->config & (1 << 19))) /* TURBO */ s->irqst |= 1 << (2 + 4 * chnum); /* RX_FULL */ if ((ch->status & (1 << 1)) && /* TXS */ ((ch->config >> 12) & 3) != 1) /* TRM */ s->irqst |= 1 << (0 + 4 * chnum); /* TX_EMPTY */ omap_mcspi_interrupt_update(s); omap_mcspi_dmarequest_update(ch); } void omap_mcspi_reset(struct omap_mcspi_s *s) { int ch; s->sysconfig = 0; s->systest = 0; s->irqst = 0; s->irqen = 0; s->wken = 0; s->control = 4; for (ch = 0; ch < 4; ch ++) { s->ch[ch].config = 0x060000; s->ch[ch].status = 2; /* TXS */ s->ch[ch].control = 0; omap_mcspi_dmarequest_update(s->ch + ch); } omap_mcspi_interrupt_update(s); } static uint64_t omap_mcspi_read(void *opaque, hwaddr addr, unsigned size) { struct omap_mcspi_s *s = (struct omap_mcspi_s *) opaque; int ch = 0; uint32_t ret; if (size != 4) { return omap_badwidth_read32(opaque, addr); } switch (addr) { case 0x00: /* MCSPI_REVISION */ return 0x91; case 0x10: /* MCSPI_SYSCONFIG */ return s->sysconfig; case 0x14: /* MCSPI_SYSSTATUS */ return 1; /* RESETDONE */ case 0x18: /* MCSPI_IRQSTATUS */ return s->irqst; case 0x1c: /* MCSPI_IRQENABLE */ return s->irqen; case 0x20: /* MCSPI_WAKEUPENABLE */ return s->wken; case 0x24: /* MCSPI_SYST */ return s->systest; case 0x28: /* MCSPI_MODULCTRL */ return s->control; case 0x68: ch ++; /* fall through */ case 0x54: ch ++; /* fall through */ case 0x40: ch ++; /* fall through */ case 0x2c: /* MCSPI_CHCONF */ return s->ch[ch].config; case 0x6c: ch ++; /* fall through */ case 0x58: ch ++; /* fall through */ case 0x44: ch ++; /* fall through */ case 0x30: /* MCSPI_CHSTAT */ return s->ch[ch].status; case 0x70: ch ++; /* fall through */ case 0x5c: ch ++; /* fall through */ case 0x48: ch ++; /* fall through */ case 0x34: /* MCSPI_CHCTRL */ return s->ch[ch].control; case 0x74: ch ++; /* fall through */ case 0x60: ch ++; /* fall through */ case 0x4c: ch ++; /* fall through */ case 0x38: /* MCSPI_TX */ return s->ch[ch].tx; case 0x78: ch ++; /* fall through */ case 0x64: ch ++; /* fall through */ case 0x50: ch ++; /* fall through */ case 0x3c: /* MCSPI_RX */ s->ch[ch].status &= ~(1 << 0); /* RXS */ ret = s->ch[ch].rx; omap_mcspi_transfer_run(s, ch); return ret; } OMAP_BAD_REG(addr); return 0; } static void omap_mcspi_write(void *opaque, hwaddr addr, uint64_t value, unsigned size) { struct omap_mcspi_s *s = (struct omap_mcspi_s *) opaque; int ch = 0; if (size != 4) { omap_badwidth_write32(opaque, addr, value); return; } switch (addr) { case 0x00: /* MCSPI_REVISION */ case 0x14: /* MCSPI_SYSSTATUS */ case 0x30: /* MCSPI_CHSTAT0 */ case 0x3c: /* MCSPI_RX0 */ case 0x44: /* MCSPI_CHSTAT1 */ case 0x50: /* MCSPI_RX1 */ case 0x58: /* MCSPI_CHSTAT2 */ case 0x64: /* MCSPI_RX2 */ case 0x6c: /* MCSPI_CHSTAT3 */ case 0x78: /* MCSPI_RX3 */ OMAP_RO_REG(addr); return; case 0x10: /* MCSPI_SYSCONFIG */ if (value & (1 << 1)) /* SOFTRESET */ omap_mcspi_reset(s); s->sysconfig = value & 0x31d; break; case 0x18: /* MCSPI_IRQSTATUS */ if (!((s->control & (1 << 3)) && (s->systest & (1 << 11)))) { s->irqst &= ~value; omap_mcspi_interrupt_update(s); } break; case 0x1c: /* MCSPI_IRQENABLE */ s->irqen = value & 0x1777f; omap_mcspi_interrupt_update(s); break; case 0x20: /* MCSPI_WAKEUPENABLE */ s->wken = value & 1; break; case 0x24: /* MCSPI_SYST */ if (s->control & (1 << 3)) /* SYSTEM_TEST */ if (value & (1 << 11)) { /* SSB */ s->irqst |= 0x1777f; omap_mcspi_interrupt_update(s); } s->systest = value & 0xfff; break; case 0x28: /* MCSPI_MODULCTRL */ if (value & (1 << 3)) /* SYSTEM_TEST */ if (s->systest & (1 << 11)) { /* SSB */ s->irqst |= 0x1777f; omap_mcspi_interrupt_update(s); } s->control = value & 0xf; break; case 0x68: ch ++; /* fall through */ case 0x54: ch ++; /* fall through */ case 0x40: ch ++; /* fall through */ case 0x2c: /* MCSPI_CHCONF */ if ((value ^ s->ch[ch].config) & (3 << 14)) /* DMAR | DMAW */ omap_mcspi_dmarequest_update(s->ch + ch); if (((value >> 12) & 3) == 3) /* TRM */ fprintf(stderr, "%s: invalid TRM value (3)\n", __FUNCTION__); if (((value >> 7) & 0x1f) < 3) /* WL */ fprintf(stderr, "%s: invalid WL value (%" PRIx64 ")\n", __FUNCTION__, (value >> 7) & 0x1f); s->ch[ch].config = value & 0x7fffff; break; case 0x70: ch ++; /* fall through */ case 0x5c: ch ++; /* fall through */ case 0x48: ch ++; /* fall through */ case 0x34: /* MCSPI_CHCTRL */ if (value & ~s->ch[ch].control & 1) { /* EN */ s->ch[ch].control |= 1; omap_mcspi_transfer_run(s, ch); } else s->ch[ch].control = value & 1; break; case 0x74: ch ++; /* fall through */ case 0x60: ch ++; /* fall through */ case 0x4c: ch ++; /* fall through */ case 0x38: /* MCSPI_TX */ s->ch[ch].tx = value; s->ch[ch].status &= ~(1 << 1); /* TXS */ omap_mcspi_transfer_run(s, ch); break; default: OMAP_BAD_REG(addr); return; } } static const MemoryRegionOps omap_mcspi_ops = { .read = omap_mcspi_read, .write = omap_mcspi_write, .endianness = DEVICE_NATIVE_ENDIAN, }; struct omap_mcspi_s *omap_mcspi_init(struct omap_target_agent_s *ta, int chnum, qemu_irq irq, qemu_irq *drq, omap_clk fclk, omap_clk iclk) { struct omap_mcspi_s *s = g_new0(struct omap_mcspi_s, 1); struct omap_mcspi_ch_s *ch = s->ch; s->irq = irq; s->chnum = chnum; while (chnum --) { ch->txdrq = *drq ++; ch->rxdrq = *drq ++; ch ++; } omap_mcspi_reset(s); memory_region_init_io(&s->iomem, NULL, &omap_mcspi_ops, s, "omap.mcspi", omap_l4_region_size(ta, 0)); omap_l4_attach(ta, 0, &s->iomem); return s; } void omap_mcspi_attach(struct omap_mcspi_s *s, uint32_t (*txrx)(void *opaque, uint32_t, int), void *opaque, int chipselect) { if (chipselect < 0 || chipselect >= s->chnum) hw_error("%s: Bad chipselect %i\n", __FUNCTION__, chipselect); s->ch[chipselect].txrx = txrx; s->ch[chipselect].opaque = opaque; }

longlong_vm@dell_book.com

1333074ef47ef099b416a615062366b52e3eb099

1744185a1e318fd0705b7c8d71635966bf2f7451

/template/lib/Projects/STM324xG_EVAL/Examples/FSMC/FSMC_SRAM_DataMemory/Src/stm32f4xx_it.c

4322586785c2bd59aeb8d68244afd9b3b24b7626

permissive

swedishhat/stm32f4-bear-metal

99554444acc611433190b00599d5be9ebbcbac49

04c8ae72ee6ea658dc376afe64f7f3a47c67512b

refs/heads/master

MIT

C

UTF-8

C

c

/** ****************************************************************************** * @file FSMC/FSMC_SRAM_DataMemory/Src/stm32f4xx_it.c * @author MCD Application Team * @version V1.2.6 * @date 06-May-2016 * @brief Main Interrupt Service Routines. * This file provides template for all exceptions handler and * peripherals interrupt service routine. ****************************************************************************** * @attention * * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2> * * Redistribution and use in source and binary forms, with or without modification, * are permitted provided that the following conditions are met: * 1. Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * 3. Neither the name of STMicroelectronics nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ****************************************************************************** */ /* Includes ------------------------------------------------------------------*/ #include "main.h" #include "stm32f4xx_it.h" /** @addtogroup STM32F4xx_HAL_Examples * @{ */ /** @addtogroup FSMC_SRAM_DataMemory * @{ */ /* Private typedef -----------------------------------------------------------*/ /* Private define ------------------------------------------------------------*/ /* Private macro -------------------------------------------------------------*/ /* Private variables ---------------------------------------------------------*/ /* Private function prototypes -----------------------------------------------*/ /* Private functions ---------------------------------------------------------*/ /******************************************************************************/ /* Cortex-M4 Processor Exceptions Handlers */ /******************************************************************************/ /** * @brief This function handles NMI exception. * @param None * @retval None */ void NMI_Handler(void) { } /** * @brief This function handles Hard Fault exception. * @param None * @retval None */ void HardFault_Handler(void) { /* Go to infinite loop when Hard Fault exception occurs */ while (1) { } } /** * @brief This function handles Memory Manage exception. * @param None * @retval None */ void MemManage_Handler(void) { /* Go to infinite loop when Memory Manage exception occurs */ while (1) { } } /** * @brief This function handles Bus Fault exception. * @param None * @retval None */ void BusFault_Handler(void) { /* Go to infinite loop when Bus Fault exception occurs */ while (1) { } } /** * @brief This function handles Usage Fault exception. * @param None * @retval None */ void UsageFault_Handler(void) { /* Go to infinite loop when Usage Fault exception occurs */ while (1) { } } /** * @brief This function handles SVCall exception. * @param None * @retval None */ void SVC_Handler(void) { } /** * @brief This function handles Debug Monitor exception. * @param None * @retval None */ void DebugMon_Handler(void) { } /** * @brief This function handles PendSVC exception. * @param None * @retval None */ void PendSV_Handler(void) { } /** * @brief This function handles SysTick Handler. * @param None * @retval None */ void SysTick_Handler(void) { HAL_IncTick(); } /******************************************************************************/ /* STM32F4xx Peripherals Interrupt Handlers */ /* Add here the Interrupt Handler for the used peripheral(s) (PPP), for the */ /* available peripheral interrupt handler's name please refer to the startup */ /* file (startup_stm32f4xx.s). */ /******************************************************************************/ /** * @brief This function handles PPP interrupt request. * @param None * @retval None */ /*void PPP_IRQHandler(void) { }*/ /** * @} */ /** * @} */ /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

patrick.d.lloyd@gmail.com

e354269707a6613f4991b9bbd1834e80739f4adf

45d1881440cd736dc3624e69026d95922f9e1289

/Silicon/TigerlakePkg/Include/CpuPcieInfo.h

eb02a589cedf48494934c45f14896c7a603f4d12

permissive

sagraw2/slimbootloader

cf794d9cf593f4c9ee99b958ac17480e4ccbec10

c62c995e496368a4c426da478b054120ebbc8eca

refs/heads/master

BSD-2-Clause

UTF-8

C

h

/** @file This file contains definitions of PCIe controller information Copyright (c) 2018 - 2019, Intel Corporation. All rights reserved.<BR> SPDX-License-Identifier: BSD-2-Clause-Patent **/ #ifndef _CPU_PCIE_INFO_H_ #define _CPU_PCIE_INFO_H_ #define PCIE_HWEQ_COEFFS_MAX 5 /** PCIe controller configuration. **/ #define CPU_PCIE_1x16 7 #define CPU_PCIE_1x8_2x4 4 #define CPU_PCIE_2x8 5 #define CPU_PCIE_1x4 0 // // Device 1 Memory Mapped IO Register Offset Equates // #define SA_PEG_BUS_NUM 0x00 #define SA_PEG_DEV_NUM 0x01 #define SA_PEG0_DEV_NUM SA_PEG_DEV_NUM #define SA_PEG0_FUN_NUM 0x00 #define SA_PEG1_DEV_NUM SA_PEG_DEV_NUM #define SA_PEG1_FUN_NUM 0x01 #define SA_PEG2_DEV_NUM SA_PEG_DEV_NUM #define SA_PEG2_FUN_NUM 0x02 #define SA_PEG3_DEV_NUM 0x06 #define SA_PEG3_FUN_NUM 0x00 #define V_SA_PEG_VID 0x8086 #define V_PH3_FS_CR_OVR 0x3E #define B_PH3_FS_CR_OVR_EN BIT8 #define V_PH3_LF_CR_OVR 0x14 #define B_PH3_LF_CR_OVR_EN BIT16 // // Temporary Device & Function Number used for Switchable Graphics DGPU // #define SA_TEMP_DGPU_DEV 0x00 #define SA_TEMP_DGPU_FUN 0x00 #define CPU_PCIE_MAX_ROOT_PORTS 4 #define CPU_PCIE_MAX_CONTROLLERS 3 #define SA_PEG_MAX_FUN 0x04 #define SA_PEG_MAX_LANE 0x14 #define SA_PEG_MAX_BUNDLE 0x0A #define SA_PEG_MAX_FUN_GEN3 0x03 #define SA_PEG_MAX_LANE_GEN3 0x10 #define SA_PEG_MAX_BUNDLE_GEN3 0x08 #define SA_PEG0_CNT_MAX_LANE 0x10 #define SA_PEG0_CNT_MAX_BUNDLE 0x08 #define SA_PEG0_CNT_FIRST_LANE 0x00 #define SA_PEG0_CNT_FIRST_BUNDLE 0x00 #define SA_PEG0_CNT_LAST_LANE 0x0F #define SA_PEG0_CNT_LAST_BUNDLE 0x07 #define SA_PEG3_CNT_MAX_LANE 0x04 #define SA_PEG3_CNT_MAX_BUNDLE 0x02 #define SA_PEG3_CNT_FIRST_LANE 0x00 #define SA_PEG3_CNT_FIRST_BUNDLE 0x00 #define SA_PEG3_CNT_LAST_LANE 0x03 #define SA_PEG3_CNT_LAST_BUNDLE 0x01 #define SA_PEG3_CNT_MAX_LANE_GEN3 0x00 #define SA_PEG3_CNT_MAX_BUNDLE_GEN3 0x00 #define SA_PEG3_CNT_FIRST_LANE_GEN3 0x00 #define SA_PEG3_CNT_FIRST_BUNDLE_GEN3 0x00 #define SA_PEG3_CNT_LAST_LANE_GEN3 0x00 #define SA_PEG3_CNT_LAST_BUNDLE_GEN3 0x00 // // Silicon and SKU- specific MAX defines // #define SA_PEG_CNL_H_MAX_FUN SA_PEG_MAX_FUN // CNL-H- SKU supports 4 controllers with 20 PEG lanes and 10 bundles #define SA_PEG_CNL_H_MAX_LANE SA_PEG_MAX_LANE #define SA_PEG_CNL_H_MAX_BUNDLE SA_PEG_MAX_BUNDLE #define SA_PEG_NON_CNL_H_MAX_FUN 0x03 // All non-CNL-H- SKU supports 3 controllers with 16 PEG lanes and 8 bundles #define SA_PEG_NON_CNL_H_MAX_LANE 0x10 #define SA_PEG_NON_CNL_H_MAX_BUNDLE 0x08 #define DMI_AUTO 0 #define DMI_GEN1 1 #define DMI_GEN2 2 #define DMI_GEN3 3 #define PH3_METHOD_AUTO 0x0 #define PH3_METHOD_HWEQ 0x1 #define PH3_METHOD_SWEQ 0x2 #define PH3_METHOD_STATIC 0x3 #define PH3_METHOD_DISABLED 0x4 #define MAX_PRESETS 9 #define BEST_PRESETS 4 // // The PEG Disable Mask BIT0 ~ BIT3 for PEG0 ~ PEG3 // #define V_PEG_DISABLE_MASK 0x0F #define B_PEG0_DISABLE_MASK BIT0 #define B_PEG1_DISABLE_MASK BIT1 #define B_PEG2_DISABLE_MASK BIT2 #define B_PEG3_DISABLE_MASK BIT3 #define CPU_PCIE_CTRL_060 0 #define CPU_PCIE_CTRL_010 1 #define CPU_PCIE_CTRL_011_012 2 // // SIP version // #define PCIE_SIP16 0 #define PCIE_SIP17 1 #endif

guo.dong@intel.com

37d39a2e57918af3b613758d06ab5e8eb4a6a5d0

243b969733833e83002586aeeee40dc21b0d55c0

/libft/src/ft_print_byte.c

cc3c556e6d1d1ed4df4a67cb967aa9860f368353

no_license

KostyaBovt/ft_ssl

bec99134c8d4a39d523c888c9d374bd7dc29b949

bc4cbb2764dbe2703e1c749dda42e8fdc881d18c

refs/heads/master

UTF-8

C

c

/* ************************************************************************** */ /* */ /* ::: :::::::: */ /* ft_print_byte.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: kbovt <marvin@42.fr> +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2018/12/15 13:34:57 by kbovt #+# #+# */ /* Updated: 2018/12/15 13:35:47 by kbovt ### ########.fr */ /* */ /* ************************************************************************** */ #include "../includes/libft.h" void ft_print_byte(unsigned char c) { int i; unsigned char shift; i = 7; shift = 1; while (i >= 0) { (c & (shift << i)) ? write(1, "1", 1) : write(1, "0", 1); i--; } }

kbovt@e1r1p9.unit.ua

7e0f473475d35ae38dfa32db1440aac2da28a6e9

cd0ffa00c856e47050254e862c2c8651d9652ab9

/beginset36.c

2ee6692f2b39fad703b84e45148e9d86161d0c2c

no_license

RANJITHKUMAR12345/ranjith

861d4eefcf8df715af33bade03385f30a3ecebe1

92379ac8ddd8ab6f17c38ff0a3408a24a97e8dfa

refs/heads/master

UTF-8

C

c

#include<stdio.h> void main() { int a[10],i,j,tp,n; printf("enter the number"); scanf("%d",&n); printf("enter the number"); for(i=0;i<n;i++) { scanf("%d",&a[i]); } for(i=0;i<n;i++) { for(j=i+1;j<n;j++) { if(a[i]>a[j]) { tp=a[i]; a[i]=a[j]; a[j]=tp; } } } for(i=0;i<n;i++) { printf("%d",a[i]); } }

noreply@github.com

9a90ab0d4adacd276f4a6f1f675cafe6eebb8c97

206b7b2e6d7a2b55deef44d1283efdfdb9b801e1

/src/keylogger.h

8f6a0da2ee9faacaf3e4bd79e6a368dab26c07f2

no_license

MatthiasJReisinger/keylogger

c9210ed47def7c37f6365cf9f857e68e76561faf

347679078810f27550e6c386c07c3ae98a1de3c3

refs/heads/master

UTF-8

C

h

/** * key logger component * the key logger is a singleton which is only accessible * through the methods declared here. the key logger is a thread. * there can only be one key logger at a time. * * @author d412vv1n */ #ifndef KEYLOGGER_H #define KEYLOGGER_H /** * starts the key logger in a separate thread. if the key logger * has already been started, subsequent calls of this method are * ignored. * * @return 0 if the key logger started successfully, 1 if it could * not be started */ int startKeylogger(void); /** * stops the key logger and clears all resources the key logger * has been using. after the key logger has been stopped through this * method, it can be started again through the startKeylogger() method. * * @return 0 if the key logger stopped successfully, 1 if there was an error */ int stopKeylogger(void); #endif

mr@master-studios.net

2da9f5686999c7948360488a9a01990c280f5971

805263fc4563a4074df54272d6e96ade9b4ca9da

/glues/source/glues_quad.c

7b6fc207ffbb3ba12babdb7d3a1e6aec51888e3c

no_license

spygunsoft/Physic-and-Gameplay-Implementation-on-PrimeEngine

b2aa37d7781941400851e8a7551f3b789f6e5c80

f47366bd0d69691ab335924e23e915061d5ee71a

refs/heads/master

UTF-8

C

c

/* * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice including the dates of first publication and * either this permission notice or a reference to * http://oss.sgi.com/projects/FreeB/ * shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. * * Except as contained in this notice, the name of Silicon Graphics, Inc. * shall not be used in advertising or otherwise to promote the sale, use or * other dealings in this Software without prior written authorization from * Silicon Graphics, Inc. * * OpenGL ES CM 1.0 port of part of GLU by Mike Gorchak <mike@malva.ua>. */ #include <stdio.h> #include <stdlib.h> #include <math.h> #include "glues_quad.h" /* Make it not a power of two to avoid cache thrashing on the chip */ #define CACHE_SIZE 240 #undef PI #define PI 3.14159265358979323846f struct GLUquadric { GLint normals; GLboolean textureCoords; GLint orientation; GLint drawStyle; void (APIENTRY* errorCallback)( GLint ); }; GLAPI GLUquadric* APIENTRY gluNewQuadric(void) { GLUquadric *newstate; newstate=(GLUquadric*)malloc(sizeof(GLUquadric)); if (newstate==NULL) { /* Can't report an error at this point... */ return NULL; } newstate->normals=GLU_SMOOTH; newstate->textureCoords=GL_FALSE; newstate->orientation=GLU_OUTSIDE; newstate->drawStyle=GLU_FILL; newstate->errorCallback=NULL; return newstate; } GLAPI void APIENTRY gluDeleteQuadric(GLUquadric* state) { if (state!=NULL) { free(state); } } static void gluQuadricError(GLUquadric* qobj, GLenum which) { if (qobj->errorCallback) { qobj->errorCallback(which); } } GLAPI void APIENTRY gluQuadricCallback(GLUquadric* qobj, GLenum which, _GLUfuncptr fn) { switch (which) { case GLU_ERROR: qobj->errorCallback=(void(APIENTRY*)(GLint))fn; break; default: gluQuadricError(qobj, GLU_INVALID_ENUM); return; } } GLAPI void APIENTRY gluQuadricNormals(GLUquadric* qobj, GLenum normals) { switch (normals) { case GLU_SMOOTH: case GLU_FLAT: case GLU_NONE: break; default: gluQuadricError(qobj, GLU_INVALID_ENUM); return; } qobj->normals=normals; } GLAPI void APIENTRY gluQuadricTexture(GLUquadric* qobj, GLboolean textureCoords) { qobj->textureCoords=textureCoords; } GLAPI void APIENTRY gluQuadricOrientation(GLUquadric* qobj, GLenum orientation) { switch(orientation) { case GLU_OUTSIDE: case GLU_INSIDE: break; default: gluQuadricError(qobj, GLU_INVALID_ENUM); return; } qobj->orientation=orientation; } GLAPI void APIENTRY gluQuadricDrawStyle(GLUquadric* qobj, GLenum drawStyle) { switch(drawStyle) { case GLU_POINT: case GLU_LINE: case GLU_FILL: case GLU_SILHOUETTE: break; default: gluQuadricError(qobj, GLU_INVALID_ENUM); return; } qobj->drawStyle=drawStyle; } GLAPI void APIENTRY gluCylinder(GLUquadric* qobj, GLfloat baseRadius, GLfloat topRadius, GLfloat height, GLint slices, GLint stacks) { GLint i, j; GLfloat sinCache[CACHE_SIZE]; GLfloat cosCache[CACHE_SIZE]; GLfloat sinCache2[CACHE_SIZE]; GLfloat cosCache2[CACHE_SIZE]; GLfloat sinCache3[CACHE_SIZE]; GLfloat cosCache3[CACHE_SIZE]; GLfloat sintemp, costemp; GLfloat vertices[(CACHE_SIZE+1)*2][3]; GLfloat texcoords[(CACHE_SIZE+1)*2][2]; GLfloat normals[(CACHE_SIZE+1)*2][3]; GLfloat angle; GLfloat zLow, zHigh; GLfloat length; GLfloat deltaRadius; GLfloat zNormal; GLfloat xyNormalRatio; GLfloat radiusLow, radiusHigh; int needCache2, needCache3; GLboolean texcoord_enabled; GLboolean normal_enabled; GLboolean vertex_enabled; GLboolean color_enabled; if (slices>=CACHE_SIZE) { slices=CACHE_SIZE-1; } /* Avoid vertex array overflow */ if (stacks>=CACHE_SIZE) { stacks=CACHE_SIZE-1; } if (slices<2 || stacks<1 || baseRadius<0.0 || topRadius<0.0 || height<0.0) { gluQuadricError(qobj, GLU_INVALID_VALUE); return; } /* Compute length (needed for normal calculations) */ deltaRadius=baseRadius-topRadius; length=(GLfloat)sqrt(deltaRadius*deltaRadius+height*height); if (length==0.0) { gluQuadricError(qobj, GLU_INVALID_VALUE); return; } /* Cache is the vertex locations cache */ /* Cache2 is the various normals at the vertices themselves */ /* Cache3 is the various normals for the faces */ needCache2=needCache3=0; if (qobj->normals==GLU_SMOOTH) { needCache2=1; } if (qobj->normals==GLU_FLAT) { if (qobj->drawStyle!=GLU_POINT) { needCache3=1; } if (qobj->drawStyle==GLU_LINE) { needCache2=1; } } zNormal=deltaRadius/length; xyNormalRatio=height/length; for (i=0; i<slices; i++) { angle=2.0f*PI*i/slices; if (needCache2) { if (qobj->orientation==GLU_OUTSIDE) { sinCache2[i]=(GLfloat)(xyNormalRatio*sin(angle)); cosCache2[i]=(GLfloat)(xyNormalRatio*cos(angle)); } else { sinCache2[i]=(GLfloat)(-xyNormalRatio*sin(angle)); cosCache2[i]=(GLfloat)(-xyNormalRatio*cos(angle)); } } sinCache[i]=(GLfloat)sin(angle); cosCache[i]=(GLfloat)cos(angle); } if (needCache3) { for (i=0; i<slices; i++) { angle=2.0f*PI*(i-0.5f)/slices; if (qobj->orientation==GLU_OUTSIDE) { sinCache3[i]=(GLfloat)(xyNormalRatio*sin(angle)); cosCache3[i]=(GLfloat)(xyNormalRatio*cos(angle)); } else { sinCache3[i]=(GLfloat)(-xyNormalRatio*sin(angle)); cosCache3[i]=(GLfloat)(-xyNormalRatio*cos(angle)); } } } sinCache[slices]=sinCache[0]; cosCache[slices]=cosCache[0]; if (needCache2) { sinCache2[slices]=sinCache2[0]; cosCache2[slices]=cosCache2[0]; } if (needCache3) { sinCache3[slices]=sinCache3[0]; cosCache3[slices]=cosCache3[0]; } /* Store status of enabled arrays */ texcoord_enabled=GL_FALSE; //glIsEnabled(GL_TEXTURE_COORD_ARRAY); normal_enabled=GL_FALSE; //glIsEnabled(GL_NORMAL_ARRAY); vertex_enabled=GL_FALSE; //glIsEnabled(GL_VERTEX_ARRAY); color_enabled=GL_FALSE; //glIsEnabled(GL_COLOR_ARRAY); /* Enable or disable arrays */ glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(3, GL_FLOAT, 0, vertices); if (qobj->textureCoords) { glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(2, GL_FLOAT, 0, texcoords); } else { glDisableClientState(GL_TEXTURE_COORD_ARRAY); } if (qobj->normals!=GLU_NONE) { glEnableClientState(GL_NORMAL_ARRAY); glNormalPointer(GL_FLOAT, 0, normals); } else { glDisableClientState(GL_NORMAL_ARRAY); } glDisableClientState(GL_COLOR_ARRAY); switch (qobj->drawStyle) { case GLU_FILL: for (j=0; j<stacks; j++) { zLow=j*height/stacks; zHigh=(j+1)*height/stacks; radiusLow=baseRadius-deltaRadius*((GLfloat)j/stacks); radiusHigh=baseRadius-deltaRadius*((GLfloat)(j+1)/stacks); for (i=0; i<=slices; i++) { switch(qobj->normals) { case GLU_FLAT: /* per vertex normals */ normals[i*2][0]=sinCache3[i]; normals[i*2][1]=cosCache3[i]; normals[i*2][2]=zNormal; normals[i*2+1][0]=sinCache3[i]; normals[i*2+1][1]=cosCache3[i]; normals[i*2+1][2]=zNormal; break; case GLU_SMOOTH: /* per vertex normals */ normals[i*2][0]=sinCache2[i]; normals[i*2][1]=cosCache2[i]; normals[i*2][2]=zNormal; normals[i*2+1][0]=sinCache2[i]; normals[i*2+1][1]=cosCache2[i]; normals[i*2+1][2]=zNormal; break; case GLU_NONE: default: break; } if (qobj->orientation==GLU_OUTSIDE) { if (qobj->textureCoords) { texcoords[i*2][0]=1-(GLfloat)i/slices; texcoords[i*2][1]=(GLfloat)j/stacks; } vertices[i*2][0]=radiusLow*sinCache[i]; vertices[i*2][1]=radiusLow*cosCache[i]; vertices[i*2][2]=zLow; if (qobj->textureCoords) { texcoords[i*2+1][0]=1-(GLfloat)i/slices; texcoords[i*2+1][1]=(GLfloat)(j+1)/stacks; } vertices[i*2+1][0]=radiusHigh*sinCache[i]; vertices[i*2+1][1]=radiusHigh*cosCache[i]; vertices[i*2+1][2]=zHigh; } else { if (qobj->textureCoords) { texcoords[i*2][0]=1-(GLfloat)i/slices; texcoords[i*2][1]=(GLfloat)(j+1)/ stacks; } vertices[i*2][0]=radiusHigh*sinCache[i]; vertices[i*2][1]=radiusHigh*cosCache[i]; vertices[i*2][2]=zHigh; if (qobj->textureCoords) { texcoords[i*2+1][0]=1-(GLfloat)i/slices; texcoords[i*2+1][1]=(GLfloat)j/stacks; } vertices[i*2+1][0]=radiusLow*sinCache[i]; vertices[i*2+1][1]=radiusLow*cosCache[i]; vertices[i*2+1][2]=zLow; } } glDrawArrays(GL_TRIANGLE_STRIP, 0, 2*(slices+1)); } break; case GLU_POINT: for (i=0; i<slices; i++) { sintemp=sinCache[i]; costemp=cosCache[i]; for (j=0; j<=stacks; j++) { switch(qobj->normals) { case GLU_FLAT: case GLU_SMOOTH: normals[j][0]=sinCache2[i]; normals[j][1]=cosCache2[i]; normals[j][2]=zNormal; break; case GLU_NONE: default: break; } zLow=j*height/stacks; radiusLow=baseRadius-deltaRadius*((GLfloat)j/stacks); if (qobj->textureCoords) { texcoords[j][0]=1-(GLfloat)i/slices; texcoords[j][1]=(GLfloat)j/stacks; } vertices[j][0]=radiusLow*sintemp; vertices[j][1]=radiusLow*costemp; vertices[j][2]=zLow; } glDrawArrays(GL_POINTS, 0, (stacks+1)); } break; case GLU_LINE: for (j=1; j<stacks; j++) { zLow=j*height/stacks; radiusLow=baseRadius-deltaRadius*((GLfloat)j/stacks); for (i=0; i<=slices; i++) { switch(qobj->normals) { case GLU_FLAT: normals[i][0]=sinCache3[i]; normals[i][1]=cosCache3[i]; normals[i][2]=zNormal; break; case GLU_SMOOTH: normals[i][0]=sinCache2[i]; normals[i][1]=cosCache2[i]; normals[i][2]=zNormal; break; case GLU_NONE: default: break; } if (qobj->textureCoords) { texcoords[i][0]=1-(GLfloat)i/slices; texcoords[i][1]=(GLfloat)j/stacks; } vertices[i][0]=radiusLow*sinCache[i]; vertices[i][1]=radiusLow*cosCache[i]; vertices[i][2]=zLow; } glDrawArrays(GL_LINE_STRIP, 0, (slices+1)); } /* Intentionally fall through here... */ case GLU_SILHOUETTE: for (j=0; j<=stacks; j+=stacks) { zLow=j*height/stacks; radiusLow=baseRadius-deltaRadius*((GLfloat)j/stacks); for (i=0; i<=slices; i++) { switch(qobj->normals) { case GLU_FLAT: normals[i][0]=sinCache3[i]; normals[i][1]=cosCache3[i]; normals[i][2]=zNormal; break; case GLU_SMOOTH: normals[i][0]=sinCache2[i]; normals[i][1]=cosCache2[i]; normals[i][2]=zNormal; break; case GLU_NONE: default: break; } if (qobj->textureCoords) { texcoords[i][0]=1-(GLfloat)i/slices; texcoords[i][1]=(GLfloat)j/stacks; } vertices[i][0]=radiusLow*sinCache[i]; vertices[i][1]=radiusLow*cosCache[i]; vertices[i][2]=zLow; } glDrawArrays(GL_LINE_STRIP, 0, (slices+1)); } for (i=0; i<slices; i++) { sintemp=sinCache[i]; costemp=cosCache[i]; for (j=0; j<=stacks; j++) { switch(qobj->normals) { case GLU_FLAT: case GLU_SMOOTH: normals[j][0]=sinCache2[i]; normals[j][1]=cosCache2[i]; normals[j][2]=0.0f; break; case GLU_NONE: default: break; } zLow=j*height/stacks; radiusLow=baseRadius-deltaRadius*((GLfloat)j/stacks); if (qobj->textureCoords) { texcoords[j][0]=1-(GLfloat)i/slices; texcoords[j][1]=(GLfloat)j/stacks; } vertices[j][0]=radiusLow*sintemp; vertices[j][1]=radiusLow*costemp; vertices[j][2]=zLow; } glDrawArrays(GL_LINE_STRIP, 0, (stacks+1)); } break; default: break; } /* Disable or re-enable arrays */ if (vertex_enabled) { /* Re-enable vertex array */ glEnableClientState(GL_VERTEX_ARRAY); } else { glDisableClientState(GL_VERTEX_ARRAY); } if (texcoord_enabled) { glEnableClientState(GL_TEXTURE_COORD_ARRAY); } else { glDisableClientState(GL_TEXTURE_COORD_ARRAY); } if (normal_enabled) { glEnableClientState(GL_NORMAL_ARRAY); } else { glDisableClientState(GL_NORMAL_ARRAY); } if (color_enabled) { glEnableClientState(GL_COLOR_ARRAY); } else { glDisableClientState(GL_COLOR_ARRAY); } } GLAPI void APIENTRY gluDisk(GLUquadric* qobj, GLfloat innerRadius, GLfloat outerRadius, GLint slices, GLint loops) { gluPartialDisk(qobj, innerRadius, outerRadius, slices, loops, 0.0, 360.0); } GLAPI void APIENTRY gluPartialDisk(GLUquadric* qobj, GLfloat innerRadius, GLfloat outerRadius, GLint slices, GLint loops, GLfloat startAngle, GLfloat sweepAngle) { GLint i, j; GLfloat sinCache[CACHE_SIZE]; GLfloat cosCache[CACHE_SIZE]; GLfloat angle; GLfloat sintemp, costemp; GLfloat vertices[(CACHE_SIZE+1)*2][3]; GLfloat texcoords[(CACHE_SIZE+1)*2][2]; GLfloat deltaRadius; GLfloat radiusLow, radiusHigh; GLfloat texLow = 0.0, texHigh = 0.0; GLfloat angleOffset; GLint slices2; GLint finish; GLboolean texcoord_enabled; GLboolean normal_enabled; GLboolean vertex_enabled; GLboolean color_enabled; if (slices>=CACHE_SIZE) { slices=CACHE_SIZE-1; } if (slices<2 || loops<1 || outerRadius<=0.0 || innerRadius<0.0 ||innerRadius > outerRadius) { gluQuadricError(qobj, GLU_INVALID_VALUE); return; } if (sweepAngle<-360.0) { sweepAngle=-360.0; } if (sweepAngle>360.0) { sweepAngle=360.0; } if (sweepAngle<0) { startAngle+=sweepAngle; sweepAngle=-sweepAngle; } if (sweepAngle==360.0) { slices2=slices; } else { slices2=slices+1; } /* Compute length (needed for normal calculations) */ deltaRadius=outerRadius-innerRadius; /* Cache is the vertex locations cache */ angleOffset=startAngle/180.0f*PI; for (i=0; i<=slices; i++) { angle=angleOffset+((PI*sweepAngle)/180.0f)*i/slices; sinCache[i]=(GLfloat)sin(angle); cosCache[i]=(GLfloat)cos(angle); } if (sweepAngle==360.0) { sinCache[slices]=sinCache[0]; cosCache[slices]=cosCache[0]; } switch(qobj->normals) { case GLU_FLAT: case GLU_SMOOTH: if (qobj->orientation==GLU_OUTSIDE) { glNormal3f(0.0f, 0.0f, 1.0f); } else { glNormal3f(0.0f, 0.0f, -1.0f); } break; default: case GLU_NONE: break; } /* Store status of enabled arrays */ texcoord_enabled=GL_FALSE; //glIsEnabled(GL_TEXTURE_COORD_ARRAY); normal_enabled=GL_FALSE; //glIsEnabled(GL_NORMAL_ARRAY); vertex_enabled=GL_FALSE; //glIsEnabled(GL_VERTEX_ARRAY); color_enabled=GL_FALSE; //glIsEnabled(GL_COLOR_ARRAY); /* Enable arrays */ glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(3, GL_FLOAT, 0, vertices); if (qobj->textureCoords) { glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(2, GL_FLOAT, 0, texcoords); } else { glDisableClientState(GL_TEXTURE_COORD_ARRAY); } glDisableClientState(GL_NORMAL_ARRAY); glDisableClientState(GL_COLOR_ARRAY); switch (qobj->drawStyle) { case GLU_FILL: if (innerRadius==0.0) { finish=loops-1; /* Triangle strip for inner polygons */ if (qobj->textureCoords) { texcoords[0][0]=0.5f; texcoords[0][1]=0.5f; } vertices[0][0]=0.0f; vertices[0][1]=0.0f; vertices[0][2]=0.0f; radiusLow=outerRadius-deltaRadius*((GLfloat)(loops-1)/loops); if (qobj->textureCoords) { texLow=radiusLow/outerRadius/2; } if (qobj->orientation==GLU_OUTSIDE) { for (i=slices; i>=0; i--) { if (qobj->textureCoords) { texcoords[slices-i+1][0]=texLow*sinCache[i]+0.5f; texcoords[slices-i+1][1]=texLow*cosCache[i]+0.5f; } vertices[slices-i+1][0]=radiusLow*sinCache[i]; vertices[slices-i+1][1]=radiusLow*cosCache[i]; vertices[slices-i+1][2]=0.0f; } } else { for (i=0; i<=slices; i++) { if (qobj->textureCoords) { texcoords[i+1][0]=texLow*sinCache[i]+0.5f; texcoords[i+1][1]=texLow*cosCache[i]+0.5f; } vertices[i+1][0]=radiusLow*sinCache[i]; vertices[i+1][1]=radiusLow*cosCache[i]; vertices[i+1][2]=0.0f; } } glDrawArrays(GL_TRIANGLE_FAN, 0, (slices+2)); } else { finish=loops; } for (j=0; j<finish; j++) { radiusLow=outerRadius-deltaRadius*((GLfloat)j/loops); radiusHigh=outerRadius-deltaRadius*((GLfloat)(j+1)/loops); if (qobj->textureCoords) { texLow=radiusLow/outerRadius/2; texHigh=radiusHigh/outerRadius/2; } for (i=0; i<=slices; i++) { if (qobj->orientation==GLU_OUTSIDE) { if (qobj->textureCoords) { texcoords[i*2][0]=texLow*sinCache[i]+0.5f; texcoords[i*2][1]=texLow*cosCache[i]+0.5f; } vertices[i*2][0]=radiusLow*sinCache[i]; vertices[i*2][1]=radiusLow*cosCache[i]; vertices[i*2][2]=0.0; if (qobj->textureCoords) { texcoords[i*2+1][0]=texHigh*sinCache[i]+0.5f; texcoords[i*2+1][1]=texHigh*cosCache[i]+0.5f; } vertices[i*2+1][0]=radiusHigh*sinCache[i]; vertices[i*2+1][1]=radiusHigh*cosCache[i]; vertices[i*2+1][2]=0.0; } else { if (qobj->textureCoords) { texcoords[i*2][0]=texHigh*sinCache[i]+0.5f; texcoords[i*2][1]=texHigh*cosCache[i]+0.5f; } vertices[i*2][0]=radiusHigh*sinCache[i]; vertices[i*2][1]=radiusHigh*cosCache[i]; vertices[i*2][2]=0.0; if (qobj->textureCoords) { texcoords[i*2+1][0]=texLow*sinCache[i]+0.5f; texcoords[i*2+1][1]=texLow*cosCache[i]+0.5f; } vertices[i*2+1][0]=radiusLow*sinCache[i]; vertices[i*2+1][1]=radiusLow*cosCache[i]; vertices[i*2+1][2]=0.0; } } glDrawArrays(GL_TRIANGLE_STRIP, 0, ((slices+1)*2)); } break; case GLU_POINT: for (j=0; j<=loops; j++) { radiusLow=outerRadius-deltaRadius*((GLfloat)j/loops); for (i=0; i<slices2; i++) { sintemp=sinCache[i]; costemp=cosCache[i]; if (qobj->textureCoords) { texLow=radiusLow/outerRadius/2; texcoords[i][0]=texLow*sinCache[i]+0.5f; texcoords[i][1]=texLow*cosCache[i]+0.5f; } vertices[i][0]=radiusLow*sintemp; vertices[i][1]=radiusLow*costemp; vertices[i][2]=0.0f; } glDrawArrays(GL_POINTS, 0, slices2); } break; case GLU_LINE: if (innerRadius==outerRadius) { for (i=0; i<=slices; i++) { if (qobj->textureCoords) { texcoords[i][0]=sinCache[i]/2+0.5f; texcoords[i][1]=cosCache[i]/2+0.5f; } vertices[i][0]=innerRadius*sinCache[i]; vertices[i][1]=innerRadius*cosCache[i]; vertices[i][2]=0.0f; } glDrawArrays(GL_LINE_STRIP, 0, slices+1); break; } for (j=0; j<=loops; j++) { radiusLow=outerRadius-deltaRadius*((GLfloat)j/loops); if (qobj->textureCoords) { texLow=radiusLow/outerRadius/2; } for (i=0; i<=slices; i++) { if (qobj->textureCoords) { texcoords[i][0]=texLow*sinCache[i]+0.5f; texcoords[i][1]=texLow*cosCache[i]+0.5f; } vertices[i][0]=radiusLow*sinCache[i]; vertices[i][1]=radiusLow*cosCache[i]; vertices[i][2]=0.0f; } glDrawArrays(GL_LINE_STRIP, 0, slices+1); } for (i=0; i<slices2; i++) { sintemp=sinCache[i]; costemp=cosCache[i]; for (j=0; j<=loops; j++) { radiusLow=outerRadius-deltaRadius*((GLfloat)j/loops); if (qobj->textureCoords) { texLow=radiusLow/outerRadius/2; } if (qobj->textureCoords) { texcoords[j][0]=texLow*sinCache[i]+0.5f; texcoords[j][1]=texLow*cosCache[i]+0.5f; } vertices[j][0]=radiusLow*sintemp; vertices[j][1]=radiusLow*costemp; vertices[j][2]=0.0f; } glDrawArrays(GL_LINE_STRIP, 0, loops+1); } break; case GLU_SILHOUETTE: if (sweepAngle<360.0) { for (i=0; i<=slices; i+=slices) { sintemp=sinCache[i]; costemp=cosCache[i]; for (j=0; j<=loops; j++) { radiusLow=outerRadius-deltaRadius*((GLfloat)j/loops); if (qobj->textureCoords) { texLow=radiusLow/outerRadius/2; texcoords[j][0]=texLow*sinCache[i]+0.5f; texcoords[j][1]=texLow*cosCache[i]+0.5f; } vertices[j][0]=radiusLow*sintemp; vertices[j][1]=radiusLow*costemp; vertices[j][2]=0.0f; } glDrawArrays(GL_LINE_STRIP, 0, loops+1); } } for (j=0; j<=loops; j+=loops) { radiusLow=outerRadius-deltaRadius*((GLfloat)j/loops); if (qobj->textureCoords) { texLow=radiusLow/outerRadius/2; } for (i=0; i<=slices; i++) { if (qobj->textureCoords) { texcoords[i][0]=texLow*sinCache[i]+0.5f; texcoords[i][1]=texLow*cosCache[i]+0.5f; } vertices[i][0]=radiusLow*sinCache[i]; vertices[i][1]=radiusLow*cosCache[i]; vertices[i][2]=0.0f; } glDrawArrays(GL_LINE_STRIP, 0, slices+1); if (innerRadius==outerRadius) { break; } } break; default: break; } /* Disable or re-enable arrays */ if (vertex_enabled) { /* Re-enable vertex array */ glEnableClientState(GL_VERTEX_ARRAY); } else { glDisableClientState(GL_VERTEX_ARRAY); } if (texcoord_enabled) { glEnableClientState(GL_TEXTURE_COORD_ARRAY); } else { glDisableClientState(GL_TEXTURE_COORD_ARRAY); } if (normal_enabled) { glEnableClientState(GL_NORMAL_ARRAY); } else { glDisableClientState(GL_NORMAL_ARRAY); } if (color_enabled) { glEnableClientState(GL_COLOR_ARRAY); } else { glDisableClientState(GL_COLOR_ARRAY); } } GLAPI void APIENTRY gluSphere(GLUquadric* qobj, GLfloat radius, GLint slices, GLint stacks) { GLint i, j; GLfloat sinCache1a[CACHE_SIZE]; GLfloat cosCache1a[CACHE_SIZE]; GLfloat sinCache2a[CACHE_SIZE]; GLfloat cosCache2a[CACHE_SIZE]; GLfloat sinCache3a[CACHE_SIZE]; GLfloat cosCache3a[CACHE_SIZE]; GLfloat sinCache1b[CACHE_SIZE]; GLfloat cosCache1b[CACHE_SIZE]; GLfloat sinCache2b[CACHE_SIZE]; GLfloat cosCache2b[CACHE_SIZE]; GLfloat sinCache3b[CACHE_SIZE]; GLfloat cosCache3b[CACHE_SIZE]; GLfloat angle; GLfloat zLow, zHigh; GLfloat sintemp1 = 0.0, sintemp2 = 0.0, sintemp3 = 0.0, sintemp4 = 0.0; GLfloat costemp1 = 0.0, costemp2 = 0.0, costemp3 = 0.0, costemp4 = 0.0; GLfloat vertices[(CACHE_SIZE+1)*2][3]; GLfloat texcoords[(CACHE_SIZE+1)*2][2]; GLfloat normals[(CACHE_SIZE+1)*2][3]; GLboolean needCache2, needCache3; GLint start, finish; GLboolean texcoord_enabled; GLboolean normal_enabled; GLboolean vertex_enabled; GLboolean color_enabled; if (slices>=CACHE_SIZE) { slices=CACHE_SIZE-1; } if (stacks>=CACHE_SIZE) { stacks=CACHE_SIZE-1; } if (slices<2 || stacks<1 || radius<0.0) { gluQuadricError(qobj, GLU_INVALID_VALUE); return; } /* Cache is the vertex locations cache */ /* Cache2 is the various normals at the vertices themselves */ /* Cache3 is the various normals for the faces */ needCache2=needCache3=GL_FALSE; if (qobj->normals==GLU_SMOOTH) { needCache2=GL_TRUE; } if (qobj->normals==GLU_FLAT) { if (qobj->drawStyle!=GLU_POINT) { needCache3=GL_TRUE; } if (qobj->drawStyle==GLU_LINE) { needCache2=GL_TRUE; } } for (i=0; i<slices; i++) { angle=2.0f*PI*i/slices; sinCache1a[i]=(GLfloat)sin(angle); cosCache1a[i]=(GLfloat)cos(angle); if (needCache2) { sinCache2a[i] = sinCache1a[i]; cosCache2a[i] = cosCache1a[i]; } } for (j=0; j<=stacks; j++) { angle=PI*j/stacks; if (needCache2) { if (qobj->orientation==GLU_OUTSIDE) { sinCache2b[j]=(GLfloat)sin(angle); cosCache2b[j]=(GLfloat)cos(angle); } else { sinCache2b[j]=(GLfloat)-sin(angle); cosCache2b[j]=(GLfloat)-cos(angle); } } sinCache1b[j]=(GLfloat)(radius*sin(angle)); cosCache1b[j]=(GLfloat)(radius*cos(angle)); } /* Make sure it comes to a point */ sinCache1b[0]=0; sinCache1b[stacks]=0; if (needCache3) { for (i=0; i<slices; i++) { angle=2.0f*PI*(i-0.5f)/slices; sinCache3a[i]=(GLfloat)sin(angle); cosCache3a[i]=(GLfloat)cos(angle); } for (j=0; j<=stacks; j++) { angle=PI*(j-0.5f)/stacks; if (qobj->orientation==GLU_OUTSIDE) { sinCache3b[j]=(GLfloat)sin(angle); cosCache3b[j]=(GLfloat)cos(angle); } else { sinCache3b[j]=(GLfloat)-sin(angle); cosCache3b[j]=(GLfloat)-cos(angle); } } } sinCache1a[slices]=sinCache1a[0]; cosCache1a[slices]=cosCache1a[0]; if (needCache2) { sinCache2a[slices]=sinCache2a[0]; cosCache2a[slices]=cosCache2a[0]; } if (needCache3) { sinCache3a[slices]=sinCache3a[0]; cosCache3a[slices]=cosCache3a[0]; } /* Store status of enabled arrays */ texcoord_enabled=GL_FALSE; //glIsEnabled(GL_TEXTURE_COORD_ARRAY); normal_enabled=GL_FALSE; //glIsEnabled(GL_NORMAL_ARRAY); vertex_enabled=GL_FALSE; //glIsEnabled(GL_VERTEX_ARRAY); color_enabled=GL_FALSE; //glIsEnabled(GL_COLOR_ARRAY); /* Enable arrays */ glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(3, GL_FLOAT, 0, vertices); if (qobj->textureCoords) { glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(2, GL_FLOAT, 0, texcoords); } else { glDisableClientState(GL_TEXTURE_COORD_ARRAY); } if (qobj->normals!=GLU_NONE) { glEnableClientState(GL_NORMAL_ARRAY); glNormalPointer(GL_FLOAT, 0, normals); } else { glDisableClientState(GL_NORMAL_ARRAY); } glDisableClientState(GL_COLOR_ARRAY); switch (qobj->drawStyle) { case GLU_FILL: if (!(qobj->textureCoords)) { start=1; finish=stacks-1; /* Low end first (j == 0 iteration) */ sintemp2=sinCache1b[1]; zHigh=cosCache1b[1]; switch(qobj->normals) { case GLU_FLAT: sintemp3=sinCache3b[1]; costemp3=cosCache3b[1]; normals[0][0]=sinCache3a[0]*sinCache3b[0]; normals[0][1]=cosCache3a[0]*sinCache3b[0]; normals[0][2]=cosCache3b[0]; break; case GLU_SMOOTH: sintemp3=sinCache2b[1]; costemp3=cosCache2b[1]; normals[0][0]=sinCache2a[0]*sinCache2b[0]; normals[0][1]=cosCache2a[0]*sinCache2b[0]; normals[0][2]=cosCache2b[0]; break; default: break; } vertices[0][0]=0.0f; vertices[0][1]=0.0f; vertices[0][2]=radius; if (qobj->orientation==GLU_OUTSIDE) { for (i=slices; i>=0; i--) { switch(qobj->normals) { case GLU_SMOOTH: normals[slices-i+1][0]=sinCache2a[i]*sintemp3; normals[slices-i+1][1]=cosCache2a[i]*sintemp3; normals[slices-i+1][2]=costemp3; break; case GLU_FLAT: if (i!=slices) { normals[slices-i+1][0]=sinCache3a[i+1]*sintemp3; normals[slices-i+1][1]=cosCache3a[i+1]*sintemp3; normals[slices-i+1][2]=costemp3; } else { /* We must add any normal here */ normals[slices-i+1][0]=sinCache3a[i]*sintemp3; normals[slices-i+1][1]=cosCache3a[i]*sintemp3; normals[slices-i+1][2]=costemp3; } break; case GLU_NONE: default: break; } vertices[slices-i+1][0]=sintemp2*sinCache1a[i]; vertices[slices-i+1][1]=sintemp2*cosCache1a[i]; vertices[slices-i+1][2]=zHigh; } } else { for (i=0; i<=slices; i++) { switch(qobj->normals) { case GLU_SMOOTH: normals[i+1][0]=sinCache2a[i]*sintemp3; normals[i+1][1]=cosCache2a[i]*sintemp3; normals[i+1][2]=costemp3; break; case GLU_FLAT: normals[i+1][0]=sinCache3a[i]*sintemp3; normals[i+1][1]=cosCache3a[i]*sintemp3; normals[i+1][2]=costemp3; break; case GLU_NONE: default: break; } vertices[i+1][0]=sintemp2*sinCache1a[i]; vertices[i+1][1]=sintemp2*cosCache1a[i]; vertices[i+1][2]=zHigh; } } glDrawArrays(GL_TRIANGLE_FAN, 0, (slices+2)); /* High end next (j==stacks-1 iteration) */ sintemp2=sinCache1b[stacks-1]; zHigh=cosCache1b[stacks-1]; switch(qobj->normals) { case GLU_FLAT: sintemp3=sinCache3b[stacks]; costemp3=cosCache3b[stacks]; normals[0][0]=sinCache3a[stacks]*sinCache3b[stacks]; normals[0][1]=cosCache3a[stacks]*sinCache3b[stacks]; normals[0][2]=cosCache3b[stacks]; break; case GLU_SMOOTH: sintemp3=sinCache2b[stacks-1]; costemp3=cosCache2b[stacks-1]; normals[0][0]=sinCache2a[stacks]*sinCache2b[stacks]; normals[0][1]=cosCache2a[stacks]*sinCache2b[stacks]; normals[0][2]=cosCache2b[stacks]; break; default: break; } vertices[0][0]=0.0f; vertices[0][1]=0.0f; vertices[0][2]=-radius; if (qobj->orientation==GLU_OUTSIDE) { for (i=0; i<=slices; i++) { switch(qobj->normals) { case GLU_SMOOTH: normals[i+1][0]=sinCache2a[i]*sintemp3; normals[i+1][1]=cosCache2a[i]*sintemp3; normals[i+1][2]=costemp3; break; case GLU_FLAT: normals[i+1][0]=sinCache3a[i]*sintemp3; normals[i+1][1]=cosCache3a[i]*sintemp3; normals[i+1][2]=costemp3; break; case GLU_NONE: default: break; } vertices[i+1][0]=sintemp2*sinCache1a[i]; vertices[i+1][1]=sintemp2*cosCache1a[i]; vertices[i+1][2]=zHigh; } } else { for (i=slices; i>=0; i--) { switch(qobj->normals) { case GLU_SMOOTH: normals[slices-i+1][0]=sinCache2a[i]*sintemp3; normals[slices-i+1][1]=cosCache2a[i]*sintemp3; normals[slices-i+1][2]=costemp3; break; case GLU_FLAT: if (i!=slices) { normals[slices-i+1][0]=sinCache3a[i+1]*sintemp3; normals[slices-i+1][1]=cosCache3a[i+1]*sintemp3; normals[slices-i+1][2]=costemp3; } else { normals[slices-i+1][0]=sinCache3a[i]*sintemp3; normals[slices-i+1][1]=cosCache3a[i]*sintemp3; normals[slices-i+1][2]=costemp3; } break; case GLU_NONE: default: break; } vertices[slices-i+1][0]=sintemp2*sinCache1a[i]; vertices[slices-i+1][1]=sintemp2*cosCache1a[i]; vertices[slices-i+1][2]=zHigh; } } glDrawArrays(GL_TRIANGLE_FAN, 0, (slices+2)); } else { start=0; finish=stacks; } for (j=start; j<finish; j++) { zLow=cosCache1b[j]; zHigh=cosCache1b[j+1]; sintemp1=sinCache1b[j]; sintemp2=sinCache1b[j+1]; switch(qobj->normals) { case GLU_FLAT: sintemp4=sinCache3b[j+1]; costemp4=cosCache3b[j+1]; break; case GLU_SMOOTH: if (qobj->orientation==GLU_OUTSIDE) { sintemp3=sinCache2b[j+1]; costemp3=cosCache2b[j+1]; sintemp4=sinCache2b[j]; costemp4=cosCache2b[j]; } else { sintemp3=sinCache2b[j]; costemp3=cosCache2b[j]; sintemp4=sinCache2b[j+1]; costemp4=cosCache2b[j+1]; } break; default: break; } for (i=0; i<=slices; i++) { switch(qobj->normals) { case GLU_SMOOTH: normals[i*2][0]=sinCache2a[i]*sintemp3; normals[i*2][1]=cosCache2a[i]*sintemp3; normals[i*2][2]=costemp3; break; case GLU_FLAT: normals[i*2][0]=sinCache3a[i]*sintemp4; normals[i*2][1]=cosCache3a[i]*sintemp4; normals[i*2][2]=costemp4; break; case GLU_NONE: default: break; } if (qobj->orientation==GLU_OUTSIDE) { if (qobj->textureCoords) { texcoords[i*2][0]=1-(GLfloat)i/slices; texcoords[i*2][1]=1-(GLfloat)(j+1)/stacks; } vertices[i*2][0]=sintemp2*sinCache1a[i]; vertices[i*2][1]=sintemp2*cosCache1a[i]; vertices[i*2][2]=zHigh; } else { if (qobj->textureCoords) { texcoords[i*2][0]=1-(GLfloat)i/slices; texcoords[i*2][1]=1-(GLfloat)j/stacks; } vertices[i*2][0]=sintemp1*sinCache1a[i]; vertices[i*2][1]=sintemp1*cosCache1a[i]; vertices[i*2][2]=zLow; } switch(qobj->normals) { case GLU_SMOOTH: normals[i*2+1][0]=sinCache2a[i]*sintemp4; normals[i*2+1][1]=cosCache2a[i]*sintemp4; normals[i*2+1][2]=costemp4; break; case GLU_FLAT: normals[i*2+1][0]=sinCache3a[i]*sintemp4; normals[i*2+1][1]=cosCache3a[i]*sintemp4; normals[i*2+1][2]=costemp4; break; case GLU_NONE: default: break; } if (qobj->orientation==GLU_OUTSIDE) { if (qobj->textureCoords) { texcoords[i*2+1][0]=1-(GLfloat)i/slices; texcoords[i*2+1][1]=1-(GLfloat)j/stacks; } vertices[i*2+1][0]=sintemp1*sinCache1a[i]; vertices[i*2+1][1]=sintemp1*cosCache1a[i]; vertices[i*2+1][2]=zLow; } else { if (qobj->textureCoords) { texcoords[i*2+1][0]=1-(GLfloat)i/slices; texcoords[i*2+1][1]=1-(GLfloat)(j+1)/stacks; } vertices[i*2+1][0]=sintemp2*sinCache1a[i]; vertices[i*2+1][1]=sintemp2*cosCache1a[i]; vertices[i*2+1][2]=zHigh; } } glDrawArrays(GL_TRIANGLE_STRIP, 0, (slices+1)*2); } break; case GLU_POINT: for (j=0; j<=stacks; j++) { sintemp1=sinCache1b[j]; costemp1=cosCache1b[j]; switch(qobj->normals) { case GLU_FLAT: case GLU_SMOOTH: sintemp2=sinCache2b[j]; costemp2=cosCache2b[j]; break; default: break; } for (i=0; i<slices; i++) { switch(qobj->normals) { case GLU_FLAT: case GLU_SMOOTH: normals[i][0]=sinCache2a[i]*sintemp2; normals[i][1]=cosCache2a[i]*sintemp2; normals[i][2]=costemp2; break; case GLU_NONE: default: break; } zLow=j*radius/stacks; if (qobj->textureCoords) { texcoords[i][0]=1-(GLfloat)i/slices; texcoords[i][1]=1-(GLfloat)j/stacks; } vertices[i][0]=sintemp1*sinCache1a[i]; vertices[i][1]=sintemp1*cosCache1a[i]; vertices[i][2]=costemp1; } glDrawArrays(GL_POINTS, 0, slices); } break; case GLU_LINE: case GLU_SILHOUETTE: for (j=1; j<stacks; j++) { sintemp1=sinCache1b[j]; costemp1=cosCache1b[j]; switch(qobj->normals) { case GLU_FLAT: case GLU_SMOOTH: sintemp2=sinCache2b[j]; costemp2=cosCache2b[j]; break; default: break; } for (i=0; i<=slices; i++) { switch(qobj->normals) { case GLU_FLAT: normals[i][0]=sinCache3a[i]*sintemp2; normals[i][1]=cosCache3a[i]*sintemp2; normals[i][2]=costemp2; break; case GLU_SMOOTH: normals[i][0]=sinCache2a[i]*sintemp2; normals[i][1]=cosCache2a[i]*sintemp2; normals[i][2]=costemp2; break; case GLU_NONE: default: break; } if (qobj->textureCoords) { texcoords[i][0]=1-(GLfloat)i/slices; texcoords[i][1]=1-(GLfloat)j/stacks; } vertices[i][0]=sintemp1*sinCache1a[i]; vertices[i][1]=sintemp1*cosCache1a[i]; vertices[i][2]=costemp1; } glDrawArrays(GL_LINE_STRIP, 0, slices+1); } for (i=0; i<slices; i++) { sintemp1=sinCache1a[i]; costemp1=cosCache1a[i]; switch(qobj->normals) { case GLU_FLAT: case GLU_SMOOTH: sintemp2=sinCache2a[i]; costemp2=cosCache2a[i]; break; default: break; } for (j=0; j<=stacks; j++) { switch(qobj->normals) { case GLU_FLAT: normals[j][0]=sintemp2*sinCache3b[j]; normals[j][1]=costemp2*sinCache3b[j]; normals[j][2]=cosCache3b[j]; break; case GLU_SMOOTH: normals[j][0]=sintemp2*sinCache2b[j]; normals[j][1]=costemp2*sinCache2b[j]; normals[j][2]=cosCache2b[j]; break; case GLU_NONE: default: break; } if (qobj->textureCoords) { texcoords[j][0]=1-(GLfloat)i/slices; texcoords[j][1]=1-(GLfloat)j/stacks; } vertices[j][0]=sintemp1*sinCache1b[j]; vertices[j][1]=costemp1*sinCache1b[j]; vertices[j][2]=cosCache1b[j]; } glDrawArrays(GL_LINE_STRIP, 0, stacks+1); } break; default: break; } /* Disable or re-enable arrays */ if (vertex_enabled) { /* Re-enable vertex array */ glEnableClientState(GL_VERTEX_ARRAY); } else { glDisableClientState(GL_VERTEX_ARRAY); } if (texcoord_enabled) { glEnableClientState(GL_TEXTURE_COORD_ARRAY); } else { glDisableClientState(GL_TEXTURE_COORD_ARRAY); } if (normal_enabled) { glEnableClientState(GL_NORMAL_ARRAY); } else { glDisableClientState(GL_NORMAL_ARRAY); } if (color_enabled) { glEnableClientState(GL_COLOR_ARRAY); } else { glDisableClientState(GL_COLOR_ARRAY); } }

devel.spygunsoft@gmail.com

d97fd8400d58fe7c7c2e3d4cdc56be9c1c672c63

e381bee2348bb2af111c726e86866a1759312563

/srcs/lst/ft_lstiter.c

a01f0fb4c1e0a119370d22e617a6e07cac39c660

no_license

AnthonyLedru/libft

852f3ccffb5ebe4a3ed17ec648ae8de54ed4ac0a

ac807dc2d59de2fea77278eae1f474fd0ff1ecf8

refs/heads/master

UTF-8

C

c

/* ************************************************************************** */ /* */ /* ::: :::::::: */ /* ft_lstiter.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: aledru <marvin@42.fr> +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/11/10 01:52:56 by aledru #+# #+# */ /* Updated: 2017/11/10 02:24:57 by aledru ### ########.fr */ /* */ /* ************************************************************************** */ #include "libft.h" void ft_lstiter(t_list *lst, void (*f)(t_list *elem)) { while (lst) { f(lst); lst = lst->next; } }

aledru@e1r10p7.42.fr

be5e0fd30545eef4145079ab6832219510e984f0

7774f5fa84edbe372df5bbb536e8b07b51306681

/Temp/StagingArea/Data/il2cppOutput/t1295.h

a44fa6b78fca3271b53f369182495cb1f49677c2

no_license

1jeffcohen/Mr-Turtle-Breaks-Free

677f4792b30ac3041e1454e6027a64478ec18a05

360506196b46e3b8234cf732230b266e655975e1

refs/heads/master

UTF-8

C

h

#pragma once #include "il2cpp-config.h" #ifndef _MSC_VER # include <alloca.h> #else # include <malloc.h> #endif #include <stdint.h> struct t322; #include "t14.h" struct t1295 : public t14 { t322* f0; };

1jeffcohen@gmail.com

4ceddd972c5c748c17bb9f57e841a370ef477ea6

fb75dcfff838efddd2148080f910608b36ee0e40

/bin/MACROS/src/CMSStyle.C

54831975de4c3d1999c57916bb3fd40e04ad4dea

no_license

iraklic/myZgamma

14231930d63c749458e85dd052cd3c3976039699

9b4ced4b134fbb4f557138fe4e6c5f6b833a1635

refs/heads/master

UTF-8

C

c

//########################################################################## // Initialization code executed at the start of a ROOT session. // // File: $Id: CMSStyle.C,v 1.1 2005/11/10 15:46:14 ganzhur Exp $ //########################################################################## //#include <iostream> //using namespace std; void CMSstyle(){ // use the 'plain' style for plots (white backgrounds, etc) // cout << "...using style 'Plain'" << endl; gROOT->SetStyle("Plain"); // Create the 'CMS' style for approved plots. Note that this style may need // some fine tuning in your macro depending on what you are plotting, e.g. // // gStyle->SetMarkerSize(0.75); // use smaller markers in a histogram with many bins // gStyle->SetTitleOffset(0.65,"y"); // bring y axis label closer to narrow values TStyle *cmsStyle= new TStyle("CMS","CMS approved plots style"); // use plain black on white colors cmsStyle->SetFrameBorderMode(0); cmsStyle->SetCanvasBorderMode(0); cmsStyle->SetPadBorderMode(0); cmsStyle->SetPadColor(0); cmsStyle->SetCanvasColor(0); cmsStyle->SetTitleColor(1); cmsStyle->SetStatColor(0); cmsStyle->SetFrameFillColor(0); cmsStyle->SetLegendBorderSize(0); // set the paper & margin sizes cmsStyle->SetPaperSize(20,26); cmsStyle->SetPadTopMargin(0.05); cmsStyle->SetPadRightMargin(0.05); cmsStyle->SetPadBottomMargin(0.17); cmsStyle->SetPadLeftMargin(0.17); // use large Times-Roman fonts cmsStyle->SetTextFont(132); cmsStyle->SetTextSize(0.08); cmsStyle->SetLabelFont(132,"x"); cmsStyle->SetLabelFont(132,"y"); cmsStyle->SetLabelFont(132,"z"); cmsStyle->SetTitleFont(132,"x"); cmsStyle->SetTitleFont(132,"y"); cmsStyle->SetTitleFont(132,"z"); cmsStyle->SetLabelSize(0.05,"x"); cmsStyle->SetTitleSize(0.06,"x"); cmsStyle->SetLabelSize(0.05,"y"); cmsStyle->SetTitleSize(0.06,"y"); cmsStyle->SetLabelSize(0.05,"z"); cmsStyle->SetTitleSize(0.06,"z"); // use bold lines and markers cmsStyle->SetMarkerStyle(8); cmsStyle->SetHistLineWidth(1.85); cmsStyle->SetLineStyleString(2,"[12 12]"); // postscript dashes // do not display any of the standard histogram decorations cmsStyle->SetOptTitle(1); cmsStyle->SetOptStat(1); cmsStyle->SetOptFit(1); // put tick marks on top and RHS of plots cmsStyle->SetPadTickX(1); cmsStyle->SetPadTickY(1); // cout << endl << " For approved plots use: gROOT->SetStyle(\"CMS\");" // << endl << " To add a CMS label use: CMSLabel();" // << endl << endl; // restore the plain style gROOT->SetStyle("Plain"); gROOT->SetStyle("CMS"); return ; }

iraklic@gmail.com

955a4350db196e2dfccbde697d8e1be98beea1a8

67d65e4ba2381b7a8ca36afb3189085512fa8197

/HttpRequest/pheader.h

ea0122c8936c4bf488c1cb0fe940583c0e1a39a3

no_license

Ryan--Yang/winpcap

6a06a8317e98b6957c3a38b7be3a22077963a1f7

f844dd097887d45da6b81fd26e6a914d6ce08b56

refs/heads/master

UTF-8

C

h

#ifndef PHEADER_H_INCLUDED #define PHEADER_H_INCLUDED /* * */ #define ETHER_ADDR_LEN 6 /* ethernet address */ #define ETHERTYPE_IP 0x0800 /* ip protocol */ #define TCP_PROTOCAL 0x0600 /* tcp protocol */ #define BUFFER_MAX_LENGTH 65536 /* buffer max length */ #define true 1 /* define true */ #define false 0 /* define false */ /* * define struct of ethernet header , ip address , ip header and tcp header */ /* ethernet header */ typedef struct ether_header { u_char ether_shost[ETHER_ADDR_LEN]; /* source ethernet address, 8 bytes */ u_char ether_dhost[ETHER_ADDR_LEN]; /* destination ethernet addresss, 8 bytes */ u_short ether_type; /* ethernet type, 16 bytes */ }ether_header; /* four bytes ip address */ typedef struct ip_address { u_char byte1; u_char byte2; u_char byte3; u_char byte4; }ip_address; /* ipv4 header */ typedef struct ip_header { u_char ver_ihl; /* version and ip header length */ u_char tos; /* type of service */ u_short tlen; /* total length */ u_short identification; /* identification */ u_short flags_fo; // flags and fragment offset u_char ttl; /* time to live */ u_char proto; /* protocol */ u_short crc; /* header checksum */ ip_address saddr; /* source address */ ip_address daddr; /* destination address */ u_int op_pad; /* option and padding */ }ip_header; /* tcp header */ typedef struct tcp_header { u_short th_sport; /* source port */ u_short th_dport; /* destination port */ u_int th_seq; /* sequence number */ u_int th_ack; /* acknowledgement number */ u_short th_len_resv_code; /* datagram length and reserved code */ u_short th_window; /* window */ u_short th_sum; /* checksum */ u_short th_urp; /* urgent pointer */ }tcp_header; #endif // PHEADER_H_INCLUDED

yfnick2010@gmail.com

34bfe63f15c2d0a942627f591bc3308707cd0dfd

a3421ecebedf3ba47a5480776078132be98ee61c

/lib/cmds/players/money.c

4df874fda26619362b1604a0b595da7ebf03eb67

no_license

Muderru/NighmareMUD

7851738d08b0d3d6a46fc7fe32cf25b3cdaffdb0

c8f91447afaa4ff70460e300dd0a6c64e369bfd5

refs/heads/master

UTF-8

C

c

// /bin/user/_money.c // from the Nightmare mudlib // a comand to allow players to search their pockets // created by Descartes of Borg 25 april 1993 #include <lib.h> inherit LIB_DAEMON; mixed cmd(string str) { string *currs; string borg; int i, tmp; if(str) return 0; /* to allow the wiz command to work */ if( creatorp(this_player()) ) return "Sorry, coders don't get salaries here!"; currs = (string *)this_player()->GetCurrencies(); currs = filter(currs, (: this_player()->GetCurrency($1) > 0 :)); if( !currs || !sizeof(currs) ) { write("You are broke."); say(this_player()->GetName()+" comes up with empty pockets."); return 1; } say(this_player()->GetName()+" fishes through "+ possessive(this_player())+" pockets examining some money."); message("my_action", "In your pockets you find "+ ((sizeof(currs) > 1) ? "these currencies: " : "only: "), this_player()); for(borg = "", i=0, tmp = sizeof(currs); i<tmp; i++) { borg += ((this_player()->GetCurrency(currs[i]))+" "+currs[i]); if(i == tmp-1) borg +=(".\n"); else if(tmp > 2 && i == tmp-2) borg += (", and "); else if(tmp == 2) borg +=(" and "); else borg +=(", "); } message("my_action", borg, this_player()); return 1; } void help() { write("Syntax: <money>\n\n" "Allows you to search your pockets for all your money\n" "of all currency types.\n" ); }

overmind2017@yandex.ru

e29206271b16aafaa8e71c6f225e0baf2ed27bd6

f8fe633947f3db3aff35f0af688937469aa60066

/server/server.h

a72d3f102a4e7e96398bd8c41230027943ee4692

no_license

mcordischi/photosynthesis

5a25c5d5bc5d6e52e23fa53539bb899f03ba89d8

6e08001764aaf5e015e470a3ae1b74326ee087d7

refs/heads/master

UTF-8

C

h

#ifndef __SERVER_H_ #define __SERVER_H_ void listen(char* (*proc)(char*)); #endif

nico@dazeo.com.ar

8e40eeb74b69fcae2a3ec6744835ac2c616cabc7

a171838fff520661daf6f7cccb2a273a4124edc9

/NOIP2010/20100924/all/program/A王俊涛/concert.c

20e786fbc695f88625d06c284def5fb92d9a85d8

no_license

strawberryfg/pascal

5077e70900492e13d9857ab4fffd868e970a01ba

257194db62aacd2fa8024aac095df601b09f417b

refs/heads/master

UTF-8

C

c

#include <stdio.h> #include <stdlib.h> FILE *fin,*fout; int i,j,k,l,p1,p2,s1,s2; int sum1,sum2,cha; int girl[301],boy[301]; int main(int argc, char *argv[]) { fin=fopen("concert.in","r"); fout=fopen("concert.out","w"); fscanf(fin,"%d",&l); for(i=1;i<=l;i++) fscanf(fin,"%d",&girl[i]); for(i=1;i<=l;i++) fscanf(fin,"%d",&boy[i]); p1=1; p2=1; s1=1; s2=1; sum1=0; sum2=0; cha=0; while((p1<l)&&(p2<l)) {while(boy[p2]==1) p2++; while(girl[p1]==1) p1++; sum1=boy[p2]*girl[p1]; s1=p1+1; s2=p2+1; if((p2!=l)&&(p1!=l)) { for(j=1;j<p1;j++) cha=cha+girl[p1]; sum1=sum1-cha*cha; cha=0; for(j=1;j<p2;j++) cha=cha+boy[p2]; sum1=sum1-cha*cha; } else if(p1==l) {for(j=p2+1;j<=l;j++) cha=cha+boy[p2]; sum1=sum1-cha*cha; cha=0; for(j=s1;j<p1;j++) cha=cha+girl[p1]; sum1=sum1-cha*cha; } else if(p2==l) { for(j=p1+1;j<=l;j++) cha=cha+girl[p1]; sum1=sum1-cha*cha; cha=0; for(j=s2;j<p2;j++) cha=cha+boy[p2]; sum1=sum1-cha*cha; } } for(j=1;j<=l;j++) sum2=sum2+boy[j]*girl[j]; if(sum2>sum1) fprintf(fout,"%d\n",sum2); else fprintf(fout,"%d\n",sum1); return 0; }

wanqingfu@sina.com

56b300ff87268a31a62843dc4f6b607b18532df6

afc8d5a9b1c2dd476ea59a7211b455732806fdfd

/Configurations/VBF/Full2016BDT/mymacros/hww_VBF_mvaBDT14.C

05f3a8592e7615fe79e28e06efd226fbe8cf6bec

no_license

latinos/PlotsConfigurations

6d88a5ad828dde4a7f45c68765081ed182fcda21

02417839021e2112e740607b0fb78e09b58c930f

refs/heads/master

Python

UTF-8

C

c

#include <TMVA/Reader.h> using namespace std; TMVA::Reader* myreaderBDT14 = new TMVA::Reader(); // float lepton_pt1; // float lepton_pt2; float mll_52; float mjj_52; float jetpt1_52; float jetpt2_52; float detajj_52; // float ptll_52; float jeteta1_52; float jeteta2_52; float met_52; float mth_52; void initmyreaderBDT14(){ // myreaderBDT14->AddVariable( "std_vector_lepton_pt[0]", &lepton_pt1 ); // myreaderBDT14->AddVariable( "std_vector_lepton_pt[1]", &lepton_pt2 ); myreaderBDT14->AddVariable( "mll", &mll_52 ); myreaderBDT14->AddVariable( "mjj", &mjj_52 ); myreaderBDT14->AddVariable( "jetpt1", &jetpt1_52 ); myreaderBDT14->AddVariable( "jetpt2", &jetpt2_52 ); myreaderBDT14->AddVariable( "detajj",&detajj_52); // myreaderBDT14->AddVariable( "ptll", &ptll_52 ); myreaderBDT14->AddVariable( "jeteta1", &jeteta1_52); myreaderBDT14->AddVariable( "jeteta2", &jeteta2_52); myreaderBDT14->AddVariable( "metPfType1",&met_52); myreaderBDT14->AddVariable( "mth",&mth_52); TString direction = ""; direction = "/afs/cern.ch/work/a/arun/Latinos/HWW_Full2016/CMSSW_8_0_26_patch1/src/MUCCA/Optimization/weights/VBF_INCL_TMVAClassification_VBF_new_BDT14.weights.xml"; cout<<direction<<endl; myreaderBDT14->BookMVA("BDT14",direction); } float hww_VBF_mvaBDT14( //float leppt1, // float leppt2, float mll_53, float mjj_53, float jetpt1_53, float jetpt2_53, float detajj_53, // float ptllf, float jeteta1_53, float jeteta2_53, float met_53, float mth_53 ){ // lepton_pt1 = leppt1; // lepton_pt2 = leppt2; mll_52 = mll_53; mjj_52 = mjj_53; jetpt1_52 = jetpt1_53; jetpt2_52 = jetpt2_53; detajj_52 = detajj_53; // ptll_52 = ptllf; jeteta1_52 = jeteta1_53; jeteta2_52 = jeteta2_53; met_52 = met_53; mth_52 = mth_53; //cout<<"BEFORE READING!!!!!!-------"<<endl; return myreaderBDT14->EvaluateMVA("BDT14"); }

arun.kumar@cern.ch

08113360ad500737a7a5484c45b9eafc178d9774

c4afbfe1885e8d0c7a1c8b928563f7bb8ab6a683

/openETCS_Releases/v0.3-D3.6.3/KCG_GreenField/CAST_int_to_DMI_TEXT_DATA_Varia.c

cc1403d9726ddbafe4826b0732e7b218f84714c1

no_license

VladislavLasmann/srcAndBinary

cd48ebaa2f1f7f697ba5df9f38abb9ed50658e10

13aa76e545b9596f6dac84fb20480dffae7584d8

refs/heads/master

UTF-8

C

c

/* $**************** KCG Version 6.4 (build i21) **************** ** Command: kcg64.exe -config D:/Github/modeling/model/Scade/System/OBU_PreIntegrations/openETCS_EVC/KCG_GreenField/config.txt ** Generation date: 2015-11-05T08:54:04 *************************************************************$ */ #include "kcg_consts.h" #include "kcg_sensors.h" #include "CAST_int_to_DMI_TEXT_DATA_Varia.h" /* DATA::Variables::CAST_int_to_DMI_TEXT */ void CAST_int_to_DMI_TEXT_DATA_Varia( /* DATA::Variables::CAST_int_to_DMI_TEXT::dmi_text_int_array_in */ DMI_TEXT_INT_Array_T_DATA *dmi_text_int_array_in, /* DATA::Variables::CAST_int_to_DMI_TEXT::dmi_text_string_out */ DMI_TEXT_DMI_Types_Pkg *dmi_text_string_out) { static kcg_int i; /* 1 */ for (i = 0; i < 255; i++) { (*dmi_text_string_out)[i] = /* 1 */ Int_to_Char_Utilities((*dmi_text_int_array_in)[i]); } } /* $**************** KCG Version 6.4 (build i21) **************** ** CAST_int_to_DMI_TEXT_DATA_Varia.c ** Generation date: 2015-11-05T08:54:04 *************************************************************$ */

bernd.hekele@deutschebahn.com

ecdf48a5e99c03e80d3d0804d4749b5ff8d67d07

5fe634e7327f5f62bcafa356e76d46f07b794b36

/APUE/src/8/8-9_1.c

ef96ceb6650db9d35842bb2a1bc6f18626ff4e23

permissive

MarsonShine/Books

8433bc1a5757e6d85e9cd649347926cfac59af08

7265c8a6226408ae687c796f604b35320926ed79

refs/heads/master

Apache-2.0

C#

UTF-8

C

c

#include "apue.h" static void charatatime(char *); int main(void) { pid_t pid; if ((pid == fork()) < 0) { err_sys("fork error"); } else if (pid == 0) { // 子进程 charatatime("output from child\n"); } else {// 父进程 charatatime("output from parent\n"); } exit(0); } static void charatatime(char *str) { char *ptr; int c; setbuf(stdout, NULL); // 设置无缓冲 for (ptr = str; (c = *ptr++) != 0;) putc(c, stdout); } // 可能的输出结果： // 1. // ooutput form child // utput from parent // 2. // oooutput from child // utput from parent

ms27946@outlook.com

d590cc92c070f3e44fad3ed8985e80174f21d20b

b2d48aac47dc3a3050f9cb562808f0e6f19a36e4

/mohansai/zetair/src/bucket.c

fe2a221cbe62c8cca6760d793fd2823b8ab59b25

no_license

bhagavansprasad/students

7f7df2f4c2350025d58406794a7d94d9c8a9d7be

2822fb81cfb6714d48dea1e4957d6011ffa6198b

refs/heads/master

C

UTF-8

C

c

/* bucket.c implements a structure that manages short inverted lists by * keeping them in fixed size buckets. * * actually, since i need to do some experimentation to find the best bucket * design, it will probably implement a number of structures. There are a * number of good reasons for having different bucket structures around, * including specialising to match the current architecture endianness and * reducing costs for fixed-length entries and keys. * * The first bucket design that we will use is as follows: * * +-------------------------------+ * |num|t1p|t1l|t2p|t2l| | * +-------------------------------+ * | |xxxxx,term2|xxxxxxxxx,term1| * +-------------------------------+ * * term vectors are stored in lexographic order with the corresponding term * immediately afterward. (shown as xxxx,term1 etc). * The term length is stored in the directory as t1l, t2l etc. * The term pointers (t1p, t2p etc) point to the start of the entry for that * term, where entries are kept packed to the back of the bucket (to allow * easy appending of new entries). All entries in the directory (shown on top * row) are fixed length numbers of size 16 bits (stored in big-endian format), * which allows quick lookup given the index of the term. * The term pointers combined with knowledge of the size of the bucket * and the term lengths can be used to deduce the length of each vector. * * Bucket design 2 is the same as one, except that all entries have uniform * length and are stored (once) at the start of the bucket. * * +-------------------------------+ * |num|size|t1p|t2p| | * +-------------------------------+ * | |xxxxx,term2|xxxxxxxxx,term1| * +-------------------------------+ * * written nml 2003-10-06 * */ #include "firstinclude.h" #include "bucket.h" #include "_mem.h" #include "bit.h" #include "mem.h" #include "str.h" /* for str_ncmp use in assert */ #include "vec.h" #include "zstdint.h" #include <assert.h> #include <errno.h> #include <limits.h> #include <stdlib.h> #include <string.h> /* return address of entries (it's at the start of memory) for bucket designs * 1 and 2 */ #define B1_ENTRIES_ADDR(base) (base) #define B2_ENTRIES_ADDR(base) (base) /* return address of the pointer for entries for bucket designs 1 and 2 */ #define B1_PTR(entry) (sizeof(uint16_t) * (2 * (entry) + 1)) #define B1_PTR_ADDR(base, entry) (((char *) base) + B1_PTR(entry)) #define B2_PTR(entry) (sizeof(uint16_t) * ((entry) + 2)) #define B2_PTR_ADDR(base, entry) (((char *) base) + B2_PTR(entry)) /* return address of the size for an entry for bucket designs 1 and 2 */ #define B1_SIZE(entry) (sizeof(uint16_t) * (2 * (entry) + 2)) #define B1_SIZE_ADDR(base, entry) (((char *) base) + B1_SIZE(entry)) #define B2_SIZE(entry) (sizeof(uint16_t)) #define B2_SIZE_ADDR(base, entry) (((char *) base) + B1_SIZE(entry)) /* macro to read a vbyte number from cmem (which is incremented over the number) * into n. Note that cmem must be a uchar * */ #define GETVBYTE(cmem, n) \ if (1) { \ unsigned int GETVBYTE_count = 0; \ \ *(n) = 0; \ while ((STR_FROM_CHAR(*(cmem)) >= 128)) { \ *(n) |= (*(cmem) & 0x7f) << GETVBYTE_count; \ GETVBYTE_count += 7; \ (cmem)++; \ } \ *(n) |= STR_FROM_CHAR(*(cmem)) << GETVBYTE_count; \ (cmem)++; \ } else /* macro to put a vbyte number to cmem (which is incremented over the number) * from n (which is destroyed by the operation). Note that cmem must be * a uchar * */ #define PUTVBYTE(cmem, n) \ if (1) { \ while ((n) >= 128) { \ *(cmem) = ((n) & 0x7f) | 0x80; \ (n) >>= 7; \ (cmem)++; \ } \ *(cmem) = ((unsigned char) n); \ (cmem)++; \ } else int bucket_new(void *mem, unsigned int bucketsize, int strategy) { if (bucketsize >= UINT16_MAX) { return 0; } /* this isn't strictly necessary, but means that everything is guaranteed * to be initialised (even the space we don't use) */ memset(mem, 0, bucketsize); switch (strategy) { case 1: case 2: return 1; default: return 0; }; } int bucket_sorted(int strategy) { switch (strategy) { case 1: case 2: return 1; default: return 0; } } unsigned int bucket_entries(void *mem, unsigned int bucketsize, int strategy) { uint16_t entries; switch (strategy) { case 1: case 2: /* read number of entries */ MEM_NTOH(&entries, mem, sizeof(entries)); return entries; break; default: assert(0); return 0; break; } } unsigned int bucket_utilised(void *mem, unsigned int bucketsize, int strategy) { unsigned int i; uint16_t entries, length, utilised = 0; switch (strategy) { case 1: /* read number of entries */ MEM_NTOH(&entries, mem, sizeof(entries)); /* read each entry */ for (i = 0; i < entries; i++) { MEM_NTOH(&length, B1_SIZE_ADDR(mem, i), sizeof(length)); utilised += length; } return utilised; break; case 2: /* read number of entries */ MEM_NTOH(&entries, mem, sizeof(entries)); /* read each entry */ for (i = 0; i < entries; i++) { MEM_NTOH(&length, B2_SIZE_ADDR(mem, i), sizeof(length)); utilised += length; } return utilised; break; default: assert(0); return 0; break; } } unsigned int bucket_string(void *mem, unsigned int bucketsize, int strategy) { unsigned int i; uint16_t entries, prevptr = bucketsize, ptr, length, string = 0; switch (strategy) { case 1: /* read number of entries */ MEM_NTOH(&entries, mem, sizeof(entries)); /* read each entry */ for (i = 0; i < entries; i++) { MEM_NTOH(&ptr, B1_PTR_ADDR(mem, i), sizeof(ptr)); MEM_NTOH(&length, B1_SIZE_ADDR(mem, i), sizeof(length)); string += (prevptr - ptr) - length; prevptr = ptr; } return string; break; case 2: /* read number of entries */ MEM_NTOH(&entries, mem, sizeof(entries)); /* read each entry */ for (i = 0; i < entries; i++) { MEM_NTOH(&ptr, B2_PTR_ADDR(mem, i), sizeof(ptr)); MEM_NTOH(&length, B2_SIZE_ADDR(mem, i), sizeof(length)); string += (prevptr - ptr) - length; prevptr = ptr; } return string; break; default: assert(0); return 0; break; } } unsigned int bucket_overhead(void *mem, unsigned int bucketsize, int strategy) { uint16_t entries; switch (strategy) { case 1: case 2: /* read number of entries */ MEM_NTOH(&entries, mem, sizeof(entries)); return entries * 2 * sizeof(uint16_t) + sizeof(entries); break; default: assert(0); return 0; break; } } unsigned int bucket_unused(void *mem, unsigned int bucketsize, int strategy) { uint16_t entries, lastptr; switch (strategy) { case 1: /* read number of entries */ MEM_NTOH(&entries, mem, sizeof(entries)); /* read last entry */ if (entries) { MEM_NTOH(&lastptr, B1_PTR_ADDR(mem, entries - 1), sizeof(lastptr)); return lastptr - B1_PTR(entries); } else { return bucketsize - sizeof(entries); } break; case 2: /* read number of entries */ MEM_NTOH(&entries, mem, sizeof(entries)); /* read last entry */ if (entries) { MEM_NTOH(&lastptr, B2_PTR_ADDR(mem, entries - 1), sizeof(lastptr)); return lastptr - B2_PTR(entries); } else { return bucketsize - sizeof(entries); } break; default: assert(0); return 0; break; } } /* functions for strategy 1 */ /* binary searches a bucket for a term, returning the largest thing that is less * than or equal to the given term (this property, which the usual binary search * must be modified to provide, is important because we can then use it for * insertion sorting as well as searching) */ static unsigned int bucket1_binsearch(void *mem, unsigned int bucketsize, unsigned int entries, const char *term, unsigned int termlen) { unsigned int l, r, m, i, len, tlen; uint16_t ptr, prevptr, size; assert(entries); l = 0; r = entries - 1; while (l < r) { m = BIT_DIV2((r + l + 1), 1); /* decode m ptr */ MEM_NTOH(&ptr, B1_PTR_ADDR(mem, m), sizeof(ptr)); MEM_NTOH(&size, B1_SIZE_ADDR(mem, m), sizeof(ptr)); /* decode next pointer, so we know where this one ends */ if (m) { MEM_NTOH(&prevptr, B1_PTR_ADDR(mem, m - 1), sizeof(prevptr)); tlen = prevptr - ptr - size; len = (tlen > termlen) ? termlen : tlen; for (i = 0; i < len; i++) { if (term[i] < ((char *) mem)[i + ptr + size]) { r = m - 1; break; } else if (term[i] > ((char *) mem)[i + ptr + size]) { l = m; break; } } /* exact match of prefixes */ if (i == len) { if (termlen == tlen) { return m; } else if (termlen < tlen) { r = m - 1; } else { l = m; } } } else { /* m is first entry */ prevptr = bucketsize; tlen = prevptr - ptr - size; len = (tlen > termlen) ? termlen : tlen; for (i = 0; i < len; i++) { if (term[i] < ((char *) mem)[i + ptr + size]) { /* no exact match, act now to prevent underflow */ return 0; break; } else if (term[i] > ((char *) mem)[i + ptr + size]) { l = m; break; } } /* exact match of prefixes */ if (i == len) { if (termlen <= tlen) { /* no match, act now to prevent underflow */ return 0; } else { l = m; } } } } /* no exact match */ return l; } void *bucket1_find(void *mem, unsigned int bucketsize, const char *term, unsigned int termlen, unsigned int *veclen, unsigned int *idx) { unsigned int index, i; uint16_t entries, size, ptr, prevptr; /* read number of entries */ MEM_NTOH(&entries, B1_ENTRIES_ADDR(mem), sizeof(entries)); /* handle 0 entries case */ if (!entries) { return NULL; } index = bucket1_binsearch(mem, bucketsize, entries, term, termlen); /* decode ptr */ MEM_NTOH(&ptr, B1_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B1_SIZE_ADDR(mem, index), sizeof(ptr)); /* decode next pointer, so we know where this one ends */ if (index) { MEM_NTOH(&prevptr, B1_PTR_ADDR(mem, index - 1), sizeof(prevptr)); } else { prevptr = bucketsize; } assert(prevptr >= ptr); if (((unsigned int) prevptr - ptr) - size == termlen) { for (i = 0; i < termlen; i++) { if (term[i] != ((char *) mem)[i + ptr + size]) { return NULL; } } *veclen = size; if (idx) { *idx = index; } return ((char *) mem) + ptr; } return NULL; } void *bucket1_search(void *mem, unsigned int bucketsize, const char *term, unsigned int termlen, unsigned int *veclen, unsigned int *idx) { unsigned int index; uint16_t entries, size, ptr, prevptr; /* read number of entries */ MEM_NTOH(&entries, B1_ENTRIES_ADDR(mem), sizeof(entries)); /* handle 0 entries case */ if (!entries) { return NULL; } index = bucket1_binsearch(mem, bucketsize, entries, term, termlen); /* decode ptr */ MEM_NTOH(&ptr, B1_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B1_SIZE_ADDR(mem, index), sizeof(ptr)); /* decode next pointer, so we know where this one ends */ if (index) { MEM_NTOH(&prevptr, B1_PTR_ADDR(mem, index - 1), sizeof(prevptr)); } else { prevptr = bucketsize; } if (idx) { *idx = index; } *veclen = size; return ((char *) mem) + ptr; } void *bucket1_realloc_at(void *mem, unsigned int bucketsize, unsigned int index, unsigned int newsize, int *toobig) { unsigned int termlen; uint16_t size, lastaddr, entries, new_bucket_size, ptr, prevptr, movesize; new_bucket_size = bucketsize - sizeof(uint16_t); /* read number of entries */ MEM_NTOH(&entries, B1_ENTRIES_ADDR(mem), sizeof(entries)); /* handle 0 entries case */ if (!entries || (index >= entries)) { *toobig = 0; return NULL; } /* decode ptr */ MEM_NTOH(&ptr, B1_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B1_SIZE_ADDR(mem, index), sizeof(ptr)); /* decode next pointer, so we know where this one ends */ if (index) { MEM_NTOH(&prevptr, B1_PTR_ADDR(mem, index - 1), sizeof(prevptr)); } else { prevptr = bucketsize; } assert(prevptr >= ptr); /* read the last entry */ MEM_NTOH(&lastaddr, B1_PTR_ADDR(mem, (entries - 1)), sizeof(lastaddr)); /* infer term length */ termlen = prevptr - ptr - size; if (newsize > size) { /* allocation is growing */ if ((newsize - size) > lastaddr - B1_PTR(entries)) { /* not enough space to grow the entry */ if (termlen + newsize + sizeof(uint16_t) * 2 > new_bucket_size) { /* ... even if the bucket was empty */ *toobig = 1; } return NULL; } /* only need to move the bytes from the old entry */ movesize = size; } else { /* shrinking realloc, move only the bytes that will be preserved */ movesize = newsize; } /* move strings and vectors (careful, this line is tricky) */ memmove(((char *) mem) + lastaddr - (newsize - size), ((char *) mem) + lastaddr, ptr + movesize - lastaddr); /* adjust pointers */ assert(((newsize > size) && ptr > (newsize - size)) || ((newsize < size) && ptr > (size - newsize)) || (newsize == size)); ptr -= (newsize - size); MEM_HTON(B1_PTR_ADDR(mem, index), &ptr, sizeof(ptr)); MEM_HTON(B1_SIZE_ADDR(mem, index), &newsize, sizeof(ptr)); prevptr = ptr; for (index++; index < entries; index++) { MEM_NTOH(&ptr, B1_PTR_ADDR(mem, index), sizeof(ptr)); ptr -= (newsize - size); MEM_HTON(B1_PTR_ADDR(mem, index), &ptr, sizeof(ptr)); } /* done */ return ((char *) mem) + prevptr; } void *bucket1_realloc(void *mem, unsigned int bucketsize, const char *term, unsigned int termlen, unsigned int newsize, int *toobig) { unsigned int i, index; uint16_t entries, size, ptr, prevptr; /* read number of entries */ MEM_NTOH(&entries, B1_ENTRIES_ADDR(mem), sizeof(entries)); /* handle 0 entries case */ if (!entries) { *toobig = 0; return NULL; } index = bucket1_binsearch(mem, bucketsize, entries, term, termlen); /* verify that index points to requested term */ /* decode ptr */ MEM_NTOH(&ptr, B1_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B1_SIZE_ADDR(mem, index), sizeof(ptr)); /* decode next pointer, so we know where this one ends */ if (index) { MEM_NTOH(&prevptr, B1_PTR_ADDR(mem, index - 1), sizeof(prevptr)); } else { prevptr = bucketsize; } assert(prevptr >= ptr); if (((unsigned int) prevptr - ptr - size) == termlen) { for (i = 0; i < termlen; i++) { if (term[i] != ((char *) mem)[ptr + size + i]) { return NULL; } } return bucket1_realloc_at(mem, bucketsize, index, newsize, toobig); } else { return NULL; } } void *bucket1_alloc(void *mem, unsigned int bucketsize, const char *term, unsigned int termlen, unsigned int newsize, int *toobig, unsigned int *idx) { unsigned int index, i, len; uint16_t size, lastaddr, entries, ptr, prevptr; /* read number of entries */ MEM_NTOH(&entries, B1_ENTRIES_ADDR(mem), sizeof(entries)); size = newsize; if (entries) { /* read the last entry */ MEM_NTOH(&lastaddr, B1_PTR_ADDR(mem, (entries - 1)), sizeof(lastaddr)); /* check that we have enough space to allocate entry */ if ((size + termlen + 2 * (sizeof(uint16_t))) > (lastaddr - B1_PTR(entries))) { /* test whether theres enough space to allocate the entry if the * bucket was empty */ *toobig = (termlen + newsize + sizeof(uint16_t) * 2 > bucketsize - sizeof(entries)); return NULL; } index = bucket1_binsearch(mem, bucketsize, entries, term, termlen); /* need to do a last comparison to figure out whether we want to insert * here or in the next position */ MEM_NTOH(&ptr, B1_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B1_SIZE_ADDR(mem, index), sizeof(ptr)); /* decode next pointer, so we know where this one ends */ if (index) { MEM_NTOH(&prevptr, B1_PTR_ADDR(mem, index - 1), sizeof(prevptr)); } else { prevptr = bucketsize; } /* the way we do our binary search, the item may need to be inserted * at the *next* location (assuming that there is no exact match) */ assert(prevptr >= ptr); len = (unsigned int) (((unsigned int) prevptr - ptr - size) > termlen) ? termlen : prevptr - ptr - size; for (i = 0; i < len; i++) { if (term[i] < ((char *) mem)[i + ptr + size]) { break; } else if (term[i] > ((char *) mem)[i + ptr + size]) { index++; prevptr = ptr; MEM_NTOH(&ptr, B1_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B1_SIZE_ADDR(mem, index), sizeof(ptr)); break; } } /* exact match of prefixes */ /* XXX: should check for exact match */ if (i == len) { if (termlen > len) { index++; prevptr = ptr; MEM_NTOH(&ptr, B1_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B1_SIZE_ADDR(mem, index), sizeof(ptr)); } } /* new allocation needs to be inserted at index */ if (index < entries) { MEM_NTOH(&ptr, B1_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B1_SIZE_ADDR(mem, index), sizeof(ptr)); /* decode next pointer, so we know where this one ends */ if (index) { MEM_NTOH(&prevptr, B1_PTR_ADDR(mem, index - 1), sizeof(prevptr)); } else { prevptr = bucketsize; } /* move strings and data down */ memmove(((char *) mem) + lastaddr - termlen - newsize, ((char *) mem) + lastaddr, ptr - lastaddr + (prevptr - ptr)); /* shift pointers up */ for (i = entries; (i > index); i--) { MEM_NTOH(&ptr, B1_PTR_ADDR(mem, i - 1), sizeof(ptr)); ptr -= termlen + newsize; MEM_HTON(B1_PTR_ADDR(mem, i), &ptr, sizeof(ptr)); memcpy(B1_SIZE_ADDR(mem, i), B1_SIZE_ADDR(mem, i - 1), sizeof(size)); } ptr = prevptr - termlen - newsize; } else { ptr = lastaddr - termlen - newsize; } } else { /* check that we have enough space to allocate entry */ if (termlen + newsize + sizeof(uint16_t) * 2 > bucketsize - sizeof(entries)) { *toobig = 1; return NULL; } ptr = bucketsize - termlen - newsize; index = 0; } /* encode new pointer */ size = newsize; MEM_HTON(B1_PTR_ADDR(mem, index), &ptr, sizeof(ptr)); MEM_HTON(B1_SIZE_ADDR(mem, index), &size, sizeof(size)); /* copy new string in */ memcpy(((char *) mem) + ptr + size, term, termlen); /* encode new entries record */ entries++; MEM_HTON(B1_ENTRIES_ADDR(mem), &entries, sizeof(entries)); if (idx) { *idx = index; } return ((char *) mem) + ptr; } int bucket1_remove_at(void *mem, unsigned int bucketsize, unsigned int index) { unsigned int i; uint16_t lastaddr, entries, size, ptr, prevptr; /* read number of entries */ MEM_NTOH(&entries, B1_ENTRIES_ADDR(mem), sizeof(entries)); if (!entries || (index >= entries)) { return 0; } /* decode ptr */ MEM_NTOH(&ptr, B1_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B1_SIZE_ADDR(mem, index), sizeof(ptr)); /* decode next pointer, so we know where this one ends */ if (index) { MEM_NTOH(&prevptr, B1_PTR_ADDR(mem, index - 1), sizeof(prevptr)); } else { prevptr = bucketsize; } assert(prevptr >= ptr); /* read the last entry */ MEM_NTOH(&lastaddr, B1_PTR_ADDR(mem, (entries - 1)), sizeof(lastaddr)); /* move strings/data up */ memmove(((char *) mem) + lastaddr + (prevptr - ptr), ((char *) mem) + lastaddr, ptr - lastaddr); size = prevptr - ptr; /* update pointers */ for (i = index; i + 1 < entries; i++) { MEM_NTOH(&ptr, B1_PTR_ADDR(mem, i + 1), sizeof(ptr)); ptr += size; MEM_HTON(B1_PTR_ADDR(mem, i), &ptr, sizeof(ptr)); memcpy(B1_SIZE_ADDR(mem, i), B1_SIZE_ADDR(mem, i + 1), sizeof(size)); } /* encode new entries record */ entries--; MEM_HTON(B1_ENTRIES_ADDR(mem), &entries, sizeof(entries)); return 1; } int bucket1_remove(void *mem, unsigned int bucketsize, const char *term, unsigned int termlen) { unsigned int i, index; uint16_t entries, ptr, size, prevptr; /* read number of entries */ MEM_NTOH(&entries, B1_ENTRIES_ADDR(mem), sizeof(entries)); if (!entries) { return 0; } index = bucket1_binsearch(mem, bucketsize, entries, term, termlen); /* verify that index points to requested term */ /* decode ptr */ MEM_NTOH(&ptr, B1_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B1_SIZE_ADDR(mem, index), sizeof(ptr)); /* decode next pointer, so we know where this one ends */ if (index) { MEM_NTOH(&prevptr, B1_PTR_ADDR(mem, index - 1), sizeof(prevptr)); } else { prevptr = bucketsize; } assert(prevptr >= ptr); if (((unsigned int) prevptr - ptr - size) == termlen) { for (i = 0; i < termlen; i++) { if (term[i] != ((char *) mem)[ptr + size + i]) { return 0; } } return bucket1_remove_at(mem, bucketsize, index); } else { return 0; } } const char *bucket1_term_at(void *mem, unsigned int bucketsize, unsigned int index, unsigned int *len, void **data, unsigned int *veclen) { uint16_t addr, prevaddr, /* logically previous (physically next) address */ size, entries; /* read number of entries */ MEM_NTOH(&entries, mem, sizeof(entries)); if (index < entries) { /* read the entry */ MEM_NTOH(&addr, B1_PTR_ADDR(mem, index), sizeof(addr)); MEM_NTOH(&size, B1_SIZE_ADDR(mem, index), sizeof(size)); assert(((sizeof(addr) * entries) <= addr) && (bucketsize > addr)); if (index) { /* its not the first entry, read the previous entry's address */ MEM_NTOH(&prevaddr, B1_PTR_ADDR(mem, index - 1), sizeof(prevaddr)); } else { /* its the first entry, boundary is the end of the bucket */ prevaddr = bucketsize; } *len = prevaddr - addr - size; *veclen = size; *data = ((char *) mem) + addr; return ((char *) mem) + addr + size; } else { /* its past the last entry */ return NULL; } } int bucket1_split(void *mem1, unsigned int bucketsize1, void *mem2, unsigned int bucketsize2, unsigned int terms) { unsigned int i, j; uint16_t lastaddr, entries, size, ptr, prevptr; memset(mem2, 0, bucketsize2); /* read number of entries */ MEM_NTOH(&entries, B1_ENTRIES_ADDR(mem1), sizeof(entries)); if (terms >= entries) { return (terms == entries); } if (terms) { /* read split entry */ MEM_NTOH(&ptr, B1_PTR_ADDR(mem1, terms - 1), sizeof(ptr)); } else { ptr = bucketsize1; } /* read last entry */ MEM_NTOH(&lastaddr, B1_PTR_ADDR(mem1, entries - 1), sizeof(lastaddr)); /* copy strings and data from bucket 1 to bucket 2 */ memcpy((char *) mem2 + bucketsize2 - (ptr - lastaddr), (char *) mem1 + lastaddr, ptr - lastaddr); /* copy pointers to new bucket */ prevptr = ptr; for (j = 0, i = terms; i < entries; i++, j++) { MEM_NTOH(&ptr, B1_PTR_ADDR(mem1, i), sizeof(ptr)); ptr += bucketsize1 - prevptr; MEM_HTON(B1_PTR_ADDR(mem2, j), &ptr, sizeof(size)); memcpy(B1_SIZE_ADDR(mem2, j), B1_SIZE_ADDR(mem1, i), sizeof(size)); } /* adjust entries record in both buckets */ size = terms; mem_hton(B1_ENTRIES_ADDR(mem1), &size, sizeof(size)); entries -= size; mem_hton(B1_ENTRIES_ADDR(mem2), &entries, sizeof(entries)); return 1; } int bucket1_set_term(void *mem, unsigned int bucketsize, unsigned int termno, const char *newterm, unsigned int newtermlen, int *toobig) { unsigned int i, termlen; uint16_t size, ptr, prevptr, lastptr, entries; /* read number of entries */ MEM_NTOH(&entries, B1_ENTRIES_ADDR(mem), sizeof(entries)); if (termno >= entries) { return 0; } /* read entry, previous and last pointers */ MEM_NTOH(&ptr, B1_PTR_ADDR(mem, termno), sizeof(ptr)); if (termno + 1 < entries) { MEM_NTOH(&prevptr, B1_PTR_ADDR(mem, termno + 1), sizeof(prevptr)); /* read the last entry */ MEM_NTOH(&lastptr, B1_PTR_ADDR(mem, (entries - 1)), sizeof(lastptr)); } else { prevptr = bucketsize; lastptr = ptr; } MEM_NTOH(&size, B1_SIZE_ADDR(mem, size), sizeof(size)); termlen = prevptr - ptr - size; if (newtermlen > termlen) { /* string is growing */ /* check that we have enough space to allocate entry */ if (((newtermlen - termlen) > (lastptr - B1_PTR(entries)))) { /* not enough space to allocate the entry */ if ((newtermlen + 2 * sizeof(uint16_t) + size) > bucketsize - sizeof(entries)) { /* ... even if the bucket was empty */ *toobig = 1; } return 0; } /* move strings and data prior to the entry */ memmove(((char *) mem) + lastptr - (newtermlen - termlen), ((char *) mem) + lastptr, ptr - lastptr + size); /* update pointers prior to the entry */ for (i = termno; i < entries; i++) { MEM_NTOH(&lastptr, B1_PTR_ADDR(mem, i), sizeof(lastptr)); lastptr -= (newtermlen - termlen); MEM_HTON(B1_PTR_ADDR(mem, i), &lastptr, sizeof(lastptr)); } } else if (newtermlen < termlen) { /* string is shrinking */ /* move strings and data prior to the entry */ memmove(((char *) mem) + lastptr + (termlen - newtermlen), ((char *) mem) + lastptr, ptr - lastptr + size); /* update pointers prior to the entry */ for (i = termno; i < entries; i++) { MEM_NTOH(&lastptr, B1_PTR_ADDR(mem, i), sizeof(lastptr)); lastptr += (termlen - newtermlen); MEM_HTON(B1_PTR_ADDR(mem, i), &lastptr, sizeof(lastptr)); } } /* copy new string in */ memcpy(((char *) mem) + ptr + size, newterm, newtermlen); return 1; } int bucket1_resize(void *mem, unsigned int oldsize, unsigned int newsize) { unsigned int i; uint16_t ptr, lastptr, entries; /* read number of entries */ MEM_NTOH(&entries, B1_ENTRIES_ADDR(mem), sizeof(entries)); if (!entries) { return 1; } /* read last entry */ MEM_NTOH(&lastptr, B1_PTR_ADDR(mem, (entries - 1)), sizeof(lastptr)); if (newsize < oldsize) { /* shrinking */ if ((oldsize - newsize) > (lastptr - B1_PTR(entries))) { return 0; } /* move data and strings */ memmove(((char *) mem) + lastptr - (oldsize - newsize), ((char *) mem) + lastptr, oldsize - lastptr); /* update pointer entries */ for (i = 0; i < entries; i++) { MEM_NTOH(&ptr, B1_PTR_ADDR(mem, i), sizeof(ptr)); ptr -= (oldsize - newsize); MEM_HTON(B1_PTR_ADDR(mem, i), &ptr, sizeof(ptr)); } } else if (newsize > oldsize) { /* growing */ /* move data and strings */ memmove(((char *) mem) + lastptr + (newsize - oldsize), ((char *) mem) + lastptr, oldsize - lastptr); /* update pointer entries */ for (i = 0; i < entries; i++) { MEM_NTOH(&ptr, B1_PTR_ADDR(mem, i), sizeof(ptr)); ptr += (newsize - oldsize); MEM_HTON(B1_PTR_ADDR(mem, i), &ptr, sizeof(ptr)); } } return 1; } void *bucket1_append(void *mem, unsigned int bucketsize, const char *term, unsigned int termlen, unsigned int size, int *toobig) { uint16_t entries, lastaddr, ptr; /* read number of entries */ MEM_NTOH(&entries, B1_ENTRIES_ADDR(mem), sizeof(entries)); if (entries) { /* read the last entry */ MEM_NTOH(&lastaddr, B1_PTR_ADDR(mem, (entries - 1)), sizeof(lastaddr)); } else { lastaddr = bucketsize; } /* check that we have enough free space */ if ((size + termlen + 2 * (sizeof(uint16_t))) > (lastaddr - B1_PTR(entries))) { /* test whether theres enough space to allocate the entry if the * bucket was empty */ *toobig = (termlen + size + sizeof(uint16_t) * 2 > bucketsize - sizeof(entries)); return NULL; } /* copy term in */ memcpy(((char *) mem) + lastaddr - termlen, term, termlen); /* update entries record and pointer */ ptr = lastaddr - termlen - size; mem_hton(B1_PTR_ADDR(mem, entries), &ptr, sizeof(ptr)); ptr = size; mem_hton(B1_SIZE_ADDR(mem, entries), &ptr, sizeof(ptr)); entries++; mem_hton(B1_ENTRIES_ADDR(mem), &entries, sizeof(entries)); return ((char *) mem) + lastaddr - termlen - size; } /* functions for strategy 2 */ /* binary searches a bucket for a term, returning the largest thing that is less * than or equal to the given term (this property, which the usual binary search * must be modified to provide, is important because we can then use it for * insertion sorting as well as searching) */ static unsigned int bucket2_binsearch(void *mem, unsigned int bucketsize, unsigned int entries, const char *term, unsigned int termlen) { unsigned int l, r, m, i, len, tlen; uint16_t ptr, prevptr, size; assert(entries); l = 0; r = entries - 1; while (l < r) { m = BIT_DIV2((r + l + 1), 1); /* decode m ptr */ MEM_NTOH(&ptr, B2_PTR_ADDR(mem, m), sizeof(ptr)); MEM_NTOH(&size, B2_SIZE_ADDR(mem, m), sizeof(ptr)); /* decode next pointer, so we know where this one ends */ if (m) { MEM_NTOH(&prevptr, B2_PTR_ADDR(mem, m - 1), sizeof(prevptr)); tlen = prevptr - ptr - size; len = (tlen > termlen) ? termlen : tlen; for (i = 0; i < len; i++) { if (term[i] < ((char *) mem)[i + ptr + size]) { r = m - 1; break; } else if (term[i] > ((char *) mem)[i + ptr + size]) { l = m; break; } } /* exact match of prefixes */ if (i == len) { if (termlen == tlen) { return m; } else if (termlen < tlen) { r = m - 1; } else { l = m; } } } else { /* m is first entry */ prevptr = bucketsize; tlen = prevptr - ptr - size; len = (tlen > termlen) ? termlen : tlen; for (i = 0; i < len; i++) { if (term[i] < ((char *) mem)[i + ptr + size]) { /* no exact match, act now to prevent underflow */ return 0; break; } else if (term[i] > ((char *) mem)[i + ptr + size]) { l = m; break; } } /* exact match of prefixes */ if (i == len) { if (termlen <= tlen) { /* no match, act now to prevent underflow */ return 0; } else { l = m; } } } } /* no exact match */ return l; } void *bucket2_find(void *mem, unsigned int bucketsize, const char *term, unsigned int termlen, unsigned int *veclen, unsigned int *idx) { unsigned int index, i; uint16_t entries, size, ptr, prevptr; /* read number of entries */ MEM_NTOH(&entries, B2_ENTRIES_ADDR(mem), sizeof(entries)); /* handle 0 entries case */ if (!entries) { return NULL; } index = bucket2_binsearch(mem, bucketsize, entries, term, termlen); /* decode ptr */ MEM_NTOH(&ptr, B2_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B2_SIZE_ADDR(mem, index), sizeof(ptr)); /* decode next pointer, so we know where this one ends */ if (index) { MEM_NTOH(&prevptr, B2_PTR_ADDR(mem, index - 1), sizeof(prevptr)); } else { prevptr = bucketsize; } assert(prevptr >= ptr); if (((unsigned int) prevptr - ptr) - size == termlen) { for (i = 0; i < termlen; i++) { if (term[i] != ((char *) mem)[i + ptr + size]) { return NULL; } } *veclen = size; if (idx) { *idx = index; } return ((char *) mem) + ptr; } return NULL; } void *bucket2_search(void *mem, unsigned int bucketsize, const char *term, unsigned int termlen, unsigned int *veclen, unsigned int *idx) { unsigned int index; uint16_t entries, size, ptr, prevptr; /* read number of entries */ MEM_NTOH(&entries, B2_ENTRIES_ADDR(mem), sizeof(entries)); /* handle 0 entries case */ if (!entries) { return NULL; } index = bucket2_binsearch(mem, bucketsize, entries, term, termlen); /* decode ptr */ MEM_NTOH(&ptr, B2_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B2_SIZE_ADDR(mem, index), sizeof(ptr)); /* decode next pointer, so we know where this one ends */ if (index) { MEM_NTOH(&prevptr, B2_PTR_ADDR(mem, index - 1), sizeof(prevptr)); } else { prevptr = bucketsize; } if (idx) { *idx = index; } *veclen = size; return ((char *) mem) + ptr; } void *bucket2_realloc_at(void *mem, unsigned int bucketsize, unsigned int index, unsigned int newsize, int *toobig) { uint16_t size, entries, new_bucket_size, ptr; /* read number of entries */ MEM_NTOH(&entries, B2_ENTRIES_ADDR(mem), sizeof(entries)); /* handle 0 entries case */ if (!entries || (index >= entries)) { *toobig = 0; return NULL; } new_bucket_size = bucketsize - sizeof(uint16_t); /* decode ptr */ MEM_NTOH(&ptr, B2_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B2_SIZE_ADDR(mem, index), sizeof(ptr)); if (size == newsize) { return ((char *) mem) + ptr; } else { return NULL; } } void *bucket2_realloc(void *mem, unsigned int bucketsize, const char *term, unsigned int termlen, unsigned int newsize, int *toobig) { unsigned int i, index; uint16_t entries, size, ptr, prevptr; /* read number of entries */ MEM_NTOH(&entries, B2_ENTRIES_ADDR(mem), sizeof(entries)); /* handle 0 entries case */ if (!entries) { *toobig = 0; return NULL; } index = bucket2_binsearch(mem, bucketsize, entries, term, termlen); /* verify that index points to requested term */ /* decode ptr */ MEM_NTOH(&ptr, B2_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B2_SIZE_ADDR(mem, index), sizeof(ptr)); if (size != newsize) { return NULL; } /* decode next pointer, so we know where this one ends */ if (index) { MEM_NTOH(&prevptr, B2_PTR_ADDR(mem, index - 1), sizeof(prevptr)); } else { prevptr = bucketsize; } assert(prevptr >= ptr); if (((unsigned int) prevptr - ptr - size) == termlen) { for (i = 0; i < termlen; i++) { if (term[i] != ((char *) mem)[ptr + size + i]) { return NULL; } } return bucket2_realloc_at(mem, bucketsize, index, newsize, toobig); } else { return NULL; } } void *bucket2_alloc(void *mem, unsigned int bucketsize, const char *term, unsigned int termlen, unsigned int newsize, int *toobig, unsigned int *idx) { unsigned int index, i, len; uint16_t size, lastaddr, entries, ptr, prevptr; /* read number of entries */ MEM_NTOH(&entries, B2_ENTRIES_ADDR(mem), sizeof(entries)); MEM_NTOH(&size, B2_SIZE_ADDR(mem, 0), sizeof(size)); if (entries && (size != newsize)) { return NULL; } if (entries) { /* read the last entry */ MEM_NTOH(&lastaddr, B2_PTR_ADDR(mem, (entries - 1)), sizeof(lastaddr)); /* check that we have enough space to allocate entry */ if ((size + termlen + 2 * (sizeof(uint16_t))) > (lastaddr - B2_PTR(entries))) { /* test whether theres enough space to allocate the entry if the * bucket was empty */ *toobig = (termlen + newsize + sizeof(uint16_t) * 2 > bucketsize - sizeof(entries)); return NULL; } index = bucket2_binsearch(mem, bucketsize, entries, term, termlen); /* need to do a last comparison to figure out whether we want to insert * here or in the next position */ MEM_NTOH(&ptr, B2_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B2_SIZE_ADDR(mem, index), sizeof(ptr)); /* decode next pointer, so we know where this one ends */ if (index) { MEM_NTOH(&prevptr, B2_PTR_ADDR(mem, index - 1), sizeof(prevptr)); } else { prevptr = bucketsize; } /* the way we do our binary search, the item may need to be inserted * at the *next* location (assuming that there is no exact match) */ assert(prevptr >= ptr); len = (unsigned int) (((unsigned int) prevptr - ptr - size) > termlen) ? termlen : prevptr - ptr - size; for (i = 0; i < len; i++) { if (term[i] < ((char *) mem)[i + ptr + size]) { break; } else if (term[i] > ((char *) mem)[i + ptr + size]) { index++; prevptr = ptr; MEM_NTOH(&ptr, B2_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B2_SIZE_ADDR(mem, index), sizeof(ptr)); break; } } /* exact match of prefixes */ /* XXX: should check for exact match */ if (i == len) { if (termlen > len) { index++; prevptr = ptr; MEM_NTOH(&ptr, B2_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B2_SIZE_ADDR(mem, index), sizeof(ptr)); } } /* new allocation needs to be inserted at index */ if (index < entries) { MEM_NTOH(&ptr, B2_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B2_SIZE_ADDR(mem, index), sizeof(ptr)); /* decode next pointer, so we know where this one ends */ if (index) { MEM_NTOH(&prevptr, B2_PTR_ADDR(mem, index - 1), sizeof(prevptr)); } else { prevptr = bucketsize; } /* move strings and data down */ memmove(((char *) mem) + lastaddr - termlen - newsize, ((char *) mem) + lastaddr, ptr - lastaddr + (prevptr - ptr)); /* shift pointers up */ for (i = entries; (i > index); i--) { MEM_NTOH(&ptr, B2_PTR_ADDR(mem, i - 1), sizeof(ptr)); ptr -= termlen + newsize; MEM_HTON(B2_PTR_ADDR(mem, i), &ptr, sizeof(ptr)); memcpy(B2_SIZE_ADDR(mem, i), B2_SIZE_ADDR(mem, i - 1), sizeof(size)); } ptr = prevptr - termlen - newsize; } else { ptr = lastaddr - termlen - newsize; } } else { /* check that we have enough space to allocate entry */ if (termlen + newsize + sizeof(uint16_t) * 2 > bucketsize - sizeof(entries)) { *toobig = 1; return NULL; } ptr = bucketsize - termlen - newsize; index = 0; } /* encode new pointer */ size = newsize; MEM_HTON(B2_PTR_ADDR(mem, index), &ptr, sizeof(ptr)); MEM_HTON(B2_SIZE_ADDR(mem, index), &size, sizeof(size)); /* copy new string in */ memcpy(((char *) mem) + ptr + size, term, termlen); /* encode new entries record */ entries++; MEM_HTON(B2_ENTRIES_ADDR(mem), &entries, sizeof(entries)); if (idx) { *idx = index; } return ((char *) mem) + ptr; } int bucket2_remove_at(void *mem, unsigned int bucketsize, unsigned int index) { unsigned int i; uint16_t lastaddr, entries, size, ptr, prevptr; /* read number of entries */ MEM_NTOH(&entries, B2_ENTRIES_ADDR(mem), sizeof(entries)); if (!entries || (index >= entries)) { return 0; } /* decode ptr */ MEM_NTOH(&ptr, B2_PTR_ADDR(mem, index), sizeof(ptr)); /* decode next pointer, so we know where this one ends */ if (index) { MEM_NTOH(&prevptr, B2_PTR_ADDR(mem, index - 1), sizeof(prevptr)); } else { prevptr = bucketsize; } assert(prevptr >= ptr); /* read the last entry */ MEM_NTOH(&lastaddr, B2_PTR_ADDR(mem, (entries - 1)), sizeof(lastaddr)); /* move strings/data up */ memmove(((char *) mem) + lastaddr + (prevptr - ptr), ((char *) mem) + lastaddr, ptr - lastaddr); size = prevptr - ptr; /* update pointers */ for (i = index; i + 1 < entries; i++) { MEM_NTOH(&ptr, B2_PTR_ADDR(mem, i + 1), sizeof(ptr)); ptr += size; MEM_HTON(B2_PTR_ADDR(mem, i), &ptr, sizeof(ptr)); } /* encode new entries record */ entries--; MEM_HTON(B2_ENTRIES_ADDR(mem), &entries, sizeof(entries)); return 1; } int bucket2_remove(void *mem, unsigned int bucketsize, const char *term, unsigned int termlen) { unsigned int i, index; uint16_t entries, ptr, size, prevptr; /* read number of entries */ MEM_NTOH(&entries, B2_ENTRIES_ADDR(mem), sizeof(entries)); if (!entries) { return 0; } index = bucket2_binsearch(mem, bucketsize, entries, term, termlen); /* verify that index points to requested term */ /* decode ptr */ MEM_NTOH(&ptr, B2_PTR_ADDR(mem, index), sizeof(ptr)); MEM_NTOH(&size, B2_SIZE_ADDR(mem, index), sizeof(ptr)); /* decode next pointer, so we know where this one ends */ if (index) { MEM_NTOH(&prevptr, B2_PTR_ADDR(mem, index - 1), sizeof(prevptr)); } else { prevptr = bucketsize; } assert(prevptr >= ptr); if (((unsigned int) prevptr - ptr - size) == termlen) { for (i = 0; i < termlen; i++) { if (term[i] != ((char *) mem)[ptr + size + i]) { return 0; } } return bucket2_remove_at(mem, bucketsize, index); } else { return 0; } } const char *bucket2_term_at(void *mem, unsigned int bucketsize, unsigned int index, unsigned int *len, void **data, unsigned int *veclen) { uint16_t addr, prevaddr, /* logically previous (physically next) address */ size, entries; /* read number of entries */ MEM_NTOH(&entries, mem, sizeof(entries)); if (index < entries) { /* read the entry */ MEM_NTOH(&addr, B2_PTR_ADDR(mem, index), sizeof(addr)); MEM_NTOH(&size, B2_SIZE_ADDR(mem, index), sizeof(size)); assert(((sizeof(addr) * entries) <= addr) && (bucketsize > addr)); if (index) { /* its not the first entry, read the previous entry's address */ MEM_NTOH(&prevaddr, B2_PTR_ADDR(mem, index - 1), sizeof(prevaddr)); } else { /* its the first entry, boundary is the end of the bucket */ prevaddr = bucketsize; } *len = prevaddr - addr - size; *veclen = size; *data = ((char *) mem) + addr; return ((char *) mem) + addr + size; } else { /* its past the last entry */ return NULL; } } int bucket2_split(void *mem1, unsigned int bucketsize1, void *mem2, unsigned int bucketsize2, unsigned int terms) { unsigned int i, j; uint16_t lastaddr, entries, size, ptr, prevptr; memset(mem2, 0, bucketsize2); /* read number of entries */ MEM_NTOH(&entries, B2_ENTRIES_ADDR(mem1), sizeof(entries)); if (terms >= entries) { return (terms == entries); } if (terms) { /* read split entry */ MEM_NTOH(&ptr, B2_PTR_ADDR(mem1, terms - 1), sizeof(ptr)); } else { ptr = bucketsize1; } /* read last entry */ MEM_NTOH(&lastaddr, B2_PTR_ADDR(mem1, entries - 1), sizeof(lastaddr)); /* copy strings and data from bucket 1 to bucket 2 */ memcpy((char *) mem2 + bucketsize2 - (ptr - lastaddr), (char *) mem1 + lastaddr, ptr - lastaddr); /* copy pointers to new bucket */ prevptr = ptr; for (j = 0, i = terms; i < entries; i++, j++) { MEM_NTOH(&ptr, B2_PTR_ADDR(mem1, i), sizeof(ptr)); ptr += bucketsize1 - prevptr; MEM_HTON(B2_PTR_ADDR(mem2, j), &ptr, sizeof(size)); } memcpy(B2_SIZE_ADDR(mem2, j), B2_SIZE_ADDR(mem1, i), sizeof(size)); /* adjust entries record in both buckets */ size = terms; mem_hton(B2_ENTRIES_ADDR(mem1), &size, sizeof(size)); entries -= size; mem_hton(B2_ENTRIES_ADDR(mem2), &entries, sizeof(entries)); return 1; } int bucket2_set_term(void *mem, unsigned int bucketsize, unsigned int termno, const char *newterm, unsigned int newtermlen, int *toobig) { unsigned int i, termlen; uint16_t size, ptr, prevptr, lastptr, entries; /* read number of entries */ MEM_NTOH(&entries, B2_ENTRIES_ADDR(mem), sizeof(entries)); if (termno >= entries) { return 0; } /* read entry, previous and last pointers */ MEM_NTOH(&ptr, B2_PTR_ADDR(mem, termno), sizeof(ptr)); if (termno + 1 < entries) { MEM_NTOH(&prevptr, B2_PTR_ADDR(mem, termno + 1), sizeof(prevptr)); /* read the last entry */ MEM_NTOH(&lastptr, B2_PTR_ADDR(mem, (entries - 1)), sizeof(lastptr)); } else { prevptr = bucketsize; lastptr = ptr; } MEM_NTOH(&size, B2_SIZE_ADDR(mem, size), sizeof(size)); termlen = prevptr - ptr - size; if (newtermlen > termlen) { /* string is growing */ /* check that we have enough space to allocate entry */ if (((newtermlen - termlen) > (lastptr - B2_PTR(entries)))) { /* not enough space to allocate the entry */ if ((newtermlen + 2 * sizeof(uint16_t) + size) > bucketsize - sizeof(entries)) { /* ... even if the bucket was empty */ *toobig = 1; } return 0; } /* move strings and data prior to the entry */ memmove(((char *) mem) + lastptr - (newtermlen - termlen), ((char *) mem) + lastptr, ptr - lastptr + size); /* update pointers prior to the entry */ for (i = termno; i < entries; i++) { MEM_NTOH(&lastptr, B2_PTR_ADDR(mem, i), sizeof(lastptr)); lastptr -= (newtermlen - termlen); MEM_HTON(B2_PTR_ADDR(mem, i), &lastptr, sizeof(lastptr)); } } else if (newtermlen < termlen) { /* string is shrinking */ /* move strings and data prior to the entry */ memmove(((char *) mem) + lastptr + (termlen - newtermlen), ((char *) mem) + lastptr, ptr - lastptr + size); /* update pointers prior to the entry */ for (i = termno; i < entries; i++) { MEM_NTOH(&lastptr, B2_PTR_ADDR(mem, i), sizeof(lastptr)); lastptr += (termlen - newtermlen); MEM_HTON(B2_PTR_ADDR(mem, i), &lastptr, sizeof(lastptr)); } } /* copy new string in */ memcpy(((char *) mem) + ptr + size, newterm, newtermlen); return 1; } int bucket2_resize(void *mem, unsigned int oldsize, unsigned int newsize) { unsigned int i; uint16_t ptr, lastptr, entries; /* read number of entries */ MEM_NTOH(&entries, B2_ENTRIES_ADDR(mem), sizeof(entries)); if (!entries) { return 1; } /* read last entry */ MEM_NTOH(&lastptr, B2_PTR_ADDR(mem, (entries - 1)), sizeof(lastptr)); if (newsize < oldsize) { /* shrinking */ if ((oldsize - newsize) > (lastptr - B2_PTR(entries))) { return 0; } /* move data and strings */ memmove(((char *) mem) + lastptr - (oldsize - newsize), ((char *) mem) + lastptr, oldsize - lastptr); /* update pointer entries */ for (i = 0; i < entries; i++) { MEM_NTOH(&ptr, B2_PTR_ADDR(mem, i), sizeof(ptr)); ptr -= (oldsize - newsize); MEM_HTON(B2_PTR_ADDR(mem, i), &ptr, sizeof(ptr)); } } else if (newsize > oldsize) { /* growing */ /* move data and strings */ memmove(((char *) mem) + lastptr + (newsize - oldsize), ((char *) mem) + lastptr, oldsize - lastptr); /* update pointer entries */ for (i = 0; i < entries; i++) { MEM_NTOH(&ptr, B2_PTR_ADDR(mem, i), sizeof(ptr)); ptr += (newsize - oldsize); MEM_HTON(B2_PTR_ADDR(mem, i), &ptr, sizeof(ptr)); } } return 1; } void *bucket2_append(void *mem, unsigned int bucketsize, const char *term, unsigned int termlen, unsigned int size, int *toobig) { uint16_t entries, lastaddr, ptr; /* read number of entries */ MEM_NTOH(&entries, B2_ENTRIES_ADDR(mem), sizeof(entries)); if (entries) { /* read the last entry */ MEM_NTOH(&lastaddr, B2_PTR_ADDR(mem, (entries - 1)), sizeof(lastaddr)); } else { lastaddr = bucketsize; } /* check that we have enough free space */ if ((size + termlen + 2 * (sizeof(uint16_t))) > (lastaddr - B2_PTR(entries))) { /* test whether theres enough space to allocate the entry if the * bucket was empty */ *toobig = (termlen + size + sizeof(uint16_t) * 2 > bucketsize - sizeof(entries)); return NULL; } /* copy term in */ memcpy(((char *) mem) + lastaddr - termlen, term, termlen); /* update entries record and pointer */ ptr = lastaddr - termlen - size; mem_hton(B2_PTR_ADDR(mem, entries), &ptr, sizeof(ptr)); ptr = size; mem_hton(B2_SIZE_ADDR(mem, entries), &ptr, sizeof(ptr)); entries++; mem_hton(B2_ENTRIES_ADDR(mem), &entries, sizeof(entries)); return ((char *) mem) + lastaddr - termlen - size; } #include <stdio.h> int bucket_print(void *mem, unsigned int bucketsize, int strategy) { void *data; const char *term; unsigned int i, tlen, vlen; unsigned int state = 0; printf("%u entries\n", bucket_entries(mem, bucketsize, strategy)); while ((term = bucket_next_term(mem, bucketsize, strategy, &state, &tlen, &data, &vlen))) { putc('\'', stdout); for (i = 0; i < tlen; i++) { putc(term[i], stdout); } putc('\'', stdout); putc(' ', stdout); printf("%u %u (off %u)\n", tlen, vlen, (unsigned int) (((char *) data) - (char *) mem)); } putc('\n', stdout); return 1; } /* switching functions */ void *bucket_alloc(void *bucketmem, unsigned int bucketsize, int strategy, const char *term, unsigned int termlen, unsigned int newsize, int *toobig, unsigned int *idx) { switch (strategy) { case 1: return bucket1_alloc(bucketmem, bucketsize, term, termlen, newsize, toobig, idx); case 2: return bucket2_alloc(bucketmem, bucketsize, term, termlen, newsize, toobig, idx); default: *toobig = 0; return NULL; }; } void *bucket_find(void *bucketmem, unsigned int bucketsize, int strategy, const char *term, unsigned int termlen, unsigned int *veclen, unsigned int *idx) { switch (strategy) { case 1: return bucket1_find(bucketmem, bucketsize, term, termlen, veclen, idx); case 2: return bucket2_find(bucketmem, bucketsize, term, termlen, veclen, idx); default: return NULL; }; } void *bucket_search(void *bucketmem, unsigned int bucketsize, int strategy, const char *term, unsigned int termlen, unsigned int *veclen, unsigned int *idx) { switch (strategy) { case 1: return bucket1_search(bucketmem, bucketsize, term, termlen, veclen, idx); case 2: return bucket2_search(bucketmem, bucketsize, term, termlen, veclen, idx); default: return NULL; }; } int bucket_remove(void *bucketmem, unsigned int bucketsize, int strategy, const char *term, unsigned int termlen) { switch (strategy) { case 1: return bucket1_remove(bucketmem, bucketsize, term, termlen); case 2: return bucket2_remove(bucketmem, bucketsize, term, termlen); default: return 0; }; } int bucket_remove_at(void *bucketmem, unsigned int bucketsize, int strategy, unsigned int index) { switch (strategy) { case 1: return bucket1_remove_at(bucketmem, bucketsize, index); case 2: return bucket2_remove_at(bucketmem, bucketsize, index); default: return 0; }; } void *bucket_realloc(void *bucketmem, unsigned int bucketsize, int strategy, const char *term, unsigned int termlen, unsigned int newlen, int *toobig) { switch (strategy) { case 1: return bucket1_realloc(bucketmem, bucketsize, term, termlen, newlen, toobig); case 2: return bucket2_realloc(bucketmem, bucketsize, term, termlen, newlen, toobig); default: *toobig = 0; return NULL; }; } void *bucket_realloc_at(void *bucketmem, unsigned int bucketsize, int strategy, unsigned int index, unsigned int newlen, int *toobig) { switch (strategy) { case 1: return bucket1_realloc_at(bucketmem, bucketsize, index, newlen, toobig); case 2: return bucket2_realloc_at(bucketmem, bucketsize, index, newlen, toobig); default: *toobig = 0; return NULL; }; } const char *bucket_next_term(void *bucketmem, unsigned int bucketsize, int strategy, unsigned int *state, unsigned int *len, void **data, unsigned int *veclen) { assert(bucketsize); switch (strategy) { case 1: return bucket1_term_at(bucketmem, bucketsize, (*state)++, len, data, veclen); case 2: return bucket2_term_at(bucketmem, bucketsize, (*state)++, len, data, veclen); default: return NULL; }; } const char *bucket_term_at(void *bucketmem, unsigned int bucketsize, int strategy, unsigned int index, unsigned int *len, void **data, unsigned int *veclen) { assert(bucketsize); switch (strategy) { case 1: return bucket1_term_at(bucketmem, bucketsize, index, len, data, veclen); case 2: return bucket2_term_at(bucketmem, bucketsize, index, len, data, veclen); default: return NULL; }; } int bucket_split(void *bucketmem1, unsigned int bucketsize1, void *bucketmem2, unsigned int bucketsize2, int strategy, unsigned int split_terms) { switch (strategy) { case 1: return bucket1_split(bucketmem1, bucketsize1, bucketmem2, bucketsize2, split_terms); case 2: return bucket2_split(bucketmem1, bucketsize1, bucketmem2, bucketsize2, split_terms); default: return 0; } } int bucket_resize(void *bucketmem, unsigned int old_bucketsize, int strategy, unsigned int new_bucketsize) { switch (strategy) { case 1: return bucket1_resize(bucketmem, old_bucketsize, new_bucketsize); case 2: return bucket2_resize(bucketmem, old_bucketsize, new_bucketsize); default: return 0; }; } void *bucket_append(void *bucketmem, unsigned int bucketsize, int strategy, const char *term, unsigned int termlen, unsigned int size, int *toobig) { switch (strategy) { case 1: return bucket1_append(bucketmem, bucketsize, term, termlen, size, toobig); case 2: return bucket2_append(bucketmem, bucketsize, term, termlen, size, toobig); default: *toobig = 0; return NULL; }; } void bucket_print_split(void *bucketmem, unsigned int bucketsize, int strategy, unsigned int terms, const char *term, unsigned int termlen, unsigned int additional, int smaller) { const char *currterm; unsigned int state = 0; void *vec; unsigned int i, j, len, veclen, sum = 0; for (i = 0; i < terms; i++) { currterm = bucket_next_term(bucketmem, bucketsize, strategy, &state, &len, &vec, &veclen); assert(currterm); for (j = 0; j < len; j++) { putc(currterm[j], stdout); } printf(" (%u) ", veclen + len); sum += len + veclen; } if (smaller) { printf("(additional) "); for (j = 0; j < termlen; j++) { putc(term[j], stdout); } printf(" (%u) ", additional); sum += additional; } printf("[%u] | ", sum); sum = 0; if (!smaller) { printf("(additional) "); for (j = 0; j < termlen; j++) { putc(term[j], stdout); } printf(" (%u) ", additional); sum += additional; } while ((currterm = bucket_next_term(bucketmem, bucketsize, strategy, &state, &len, &vec, &veclen))) { for (j = 0; j < len; j++) { putc(currterm[j], stdout); } printf(" (%u) ", veclen + len); sum += len + veclen; } printf(" [%u]\n", sum); } unsigned int bucket_find_split_entry(void *bucketmem, unsigned int bucketsize, int strategy, unsigned int range, const char *term, unsigned int termlen, unsigned int additional, int *smaller) { const void *ret; /* return value from bucket functions */ void *dataptr; /* data location of vector in bucket */ int tmpsmaller = 0, /* value to be copied into smaller */ consumed = 0, /* whether the additional term has been * consumed */ cmp; /* result of string comparison */ unsigned int shortest, /* size of the shortest entry we've seen */ index, /* split bucket term index */ disp, /* displacement of shortest entry from a * perfectly balanced split */ terms = 0, /* number of terms seen thus far */ sum = 0, /* sum of data thus far */ len, /* length of string entry */ veclen, /* length of data in entry */ data, /* amount of data in bucket */ iter_state = 0; /* state of iteration */ /* determine where to split the leaf node * * prefix b-tree magic is performed here, by selecting shortest string to * push up within given range. If two strings are equally short, the * distribution of data between the buckets is considered, with more even * distribution favoured. */ assert(bucket_sorted(strategy)); /* XXX: should handle unsorted buckets * (by sorting) */ data = bucket_utilised(bucketmem, bucketsize, strategy) + bucket_string(bucketmem, bucketsize, strategy) + additional; data /= 2; /* our interval of interest is now data +/- range */ ret = bucket_next_term(bucketmem, bucketsize, strategy, &iter_state, &len, &dataptr, &veclen); assert(ret); /* iterate until we come up to term that enters range */ while (ret /* need to do comparison to additional term now so that we can stop on * term that crosses boundary into acceptable range */ && ((cmp = str_nncmp(term, termlen, ret, len)), 1) /* if additional term is less than bucket term ... */ && (((!consumed && (cmp < 0)) /* ... check that its not going to cross into range ... */ && (sum + additional < data - range) /* ... and consume it */ && ((sum += additional), (consumed = 1))) /* else if additional term is greater than bucket term or already * consumed ... */ || ((consumed || (cmp > 0)) /* ... check that bucket term isn't going to cross into range ... */ && (sum + len + veclen < data - range) && ((sum += len + veclen), ++terms) && (ret = bucket_next_term(bucketmem, bucketsize, strategy, &iter_state, &len, &dataptr, &veclen))) /* else if they're equal ... */ || ((!consumed && !cmp) /* ... check that the sum isn't going to cross into range ... */ && (sum + len + veclen + additional < data - range) /* ... and consume them */ && ((sum += len + veclen + additional), ++terms, (consumed = 1)) && (ret = bucket_next_term(bucketmem, bucketsize, strategy, &iter_state, &len, &dataptr, &veclen))))) { /* do nothing */ } /* we're now up to term that may enter range, its the answer if it crosses * the entire range. Either way we have to consume the next term here. */ /* if additional term hasn't been consumed, and is less than bucket * term ... */ if (ret && ((cmp = str_nncmp(term, termlen, ret, len)) < 0) && !consumed) { /* ... and its going to cross entire range ... */ if (sum + additional >= data + range) { /* its the splitting point, determine whether it balances better on * left or right of split and return */ *smaller = (sum + additional - data < data - sum); return terms; } else { /* its not the splitting point, or even a candidate, just consume * it */ sum += additional; consumed = 1; tmpsmaller = 1; } /* else if additional term is greater than bucket term or already * consumed ... */ } else if (ret && (consumed || (cmp > 0))) { /* ... and bucket term is going to cross entire range */ if (sum + len + veclen >= data + range) { /* its the splitting point, determine whether it balances better on * left or right of split and return */ *smaller = consumed; return terms + (sum + len + veclen - data < data - sum); } else { /* its not the splitting point, or even a candidate, consume it */ sum += len + veclen; tmpsmaller = consumed; terms++; ret = bucket_next_term(bucketmem, bucketsize, strategy, &iter_state, &len, &dataptr, &veclen); } /* else if they're equal ... */ } else if (ret && !consumed && !cmp) { /* ... check if they will cross entire range ... */ if (sum + len + veclen + additional >= data + range) { /* combination is the splitting point, determine whether it * balances better on left or right of split and return */ *smaller = (sum + len + veclen + additional - data < data - sum); return terms + *smaller; } else { /* they aren't the splitting point, or even a candidate, consume * them */ sum += len + veclen + additional; consumed = 1; tmpsmaller = 1; terms++; ret = bucket_next_term(bucketmem, bucketsize, strategy, &iter_state, &len, &dataptr, &veclen); } } /* haven't found a splitting point thus far, but everything until we exit * the range is now a candidate */ index = -1; disp = shortest = UINT_MAX; /* XXX: note that code below here hasn't really been debugged, since * ranges haven't been enabled yet */ /* iterate until we exit range */ assert(sum >= data - range); while (ret && (sum < data + range)) { cmp = str_nncmp(term, termlen, ret, len); if (!consumed && (cmp < 0)) { /* consume additional term */ /* if its the shortest entry, or equal shortest with smaller * displacement from a perfectly balanced bucket, then its our * current best candidate for splitting point */ if ((len < shortest) || ((len == shortest) && (((sum < data) && (data - sum < disp) && (((sum + additional < data) && (data - sum - additional < disp)) || ((sum + additional > data) && (sum + additional - data < disp)))) || ((sum > data) && (sum + additional - data < disp))))) { /* calculate maximum displacement of term from midpoint */ if (sum < data) { disp = data - sum; if (sum + additional > data) { if (sum + additional - data > disp) { disp = sum + additional - data; } } } else { disp = sum + additional - data; } index = terms; shortest = len; tmpsmaller = 0; } sum += additional; consumed = 1; } else { if (!consumed && !cmp) { /* consume both terms */ if ((len < shortest) || ((len == shortest) && (((sum < data) && (data - sum < disp) && (((sum + len + veclen + additional < data) && (data - sum - len - veclen - additional < disp)) || ((sum + len + veclen + additional > data) && (sum + len + veclen + additional - data < disp)))) || ((sum > data) && (sum + len + veclen + additional - data < disp))))) { /* calculate maximum displacement of term from midpoint */ if (sum < data) { disp = data - sum; if (sum + len + veclen + additional > data) { if (sum + len + veclen + additional - data > disp) { disp = sum + len + veclen + additional - data; } } } else { disp = sum + len + veclen + additional - data; } index = terms + 1; shortest = len; tmpsmaller = 0; } sum += additional + len + veclen; consumed = 1; } else { /* consume term from bucket */ if ((len < shortest) || ((len == shortest) && (((sum < data) && (data - sum < disp) && (((sum + len + veclen < data) && (data - sum - len - veclen < disp)) || ((sum + len + veclen > data) && (sum + len + veclen - data < disp)))) || ((sum > data) && (sum + len + veclen - data < disp))))) { /* calculate maximum displacement of term from midpoint */ if (sum < data) { disp = data - sum; if (sum + len + veclen > data) { if (sum + len + veclen - data > disp) { disp = sum + len + veclen - data; } } } else { disp = sum + len + veclen - data; } index = terms + 1; shortest = len; tmpsmaller = consumed; } sum += len + veclen; } /* get next term from bucket */ terms++; ret = bucket_next_term(bucketmem, bucketsize, strategy, &iter_state, &len, &dataptr, &veclen); } } assert((index != -1) && (disp != UINT_MAX) && (shortest != UINT_MAX)); *smaller = tmpsmaller; return index; }

bhagavan.prasad@blackpeppertech.com

569854ba4bcf306821fc8938cfd0e90e233272ea

7eab8a9d4e3d04842b319305e826215ca9bb5cbe

/Examples/Linux/Testbenches/ftp_test/Sources/ardrone_testing_tool.c

be67111096346633cc3a4a2efd6142545e437c72

no_license

islanderz/ARDRoneSDK

65ef37320ee439eadfd70a09ba2cb220a25e59f5

7c56c8bfb36b81c01879295cff093b1eb1a51329

refs/heads/master

UTF-8

C

c

/** * @file main.c * @author sylvain.gaeremynck@parrot.com * @date 2009/07/01 */ #include <ardrone_testing_tool.h> //ARDroneLib #include <utils/ardrone_time.h> #include <ardrone_tool/Navdata/ardrone_navdata_client.h> #include <ardrone_tool/Control/ardrone_control.h> #include <ardrone_tool/UI/ardrone_input.h> #include <ardrone_tool/ardrone_tool_configuration.h> //Common #include <config.h> #include <ardrone_api.h> //VP_SDK #include <ATcodec/ATcodec_api.h> #include <VP_Os/vp_os_print.h> #include <VP_Os/vp_os_thread.h> #include <VP_Api/vp_api_thread_helper.h> #include <VP_Os/vp_os_signal.h> #include <VP_Os/vp_os_types.h> #include <VP_Os/vp_os_delay.h> //Local project #include <Video/video_stage.h> #include <utils/ardrone_ftp.h> #include <semaphore.h> static int32_t exit_ihm_program = 1; /* Implementing Custom methods for the main function of an ARDrone application */ int main(int argc, char** argv) { return ardrone_tool_main(argc, argv); } /* The delegate object calls this method during initialization of an ARDrone application */ C_RESULT ardrone_tool_init_custom(void) { /* Start all threads of your application */ START_THREAD( main_application_thread , NULL ); return C_OK; } /* The delegate object calls this method when the event loop exit */ C_RESULT ardrone_tool_shutdown_custom() { /* Relinquish all threads of your application */ JOIN_THREAD( main_application_thread ); return C_OK; } /* The event loop calls this method for the exit condition */ bool_t ardrone_tool_exit() { return exit_ihm_program == 0; } C_RESULT signal_exit() { exit_ihm_program = 0; return C_OK; } PROTO_THREAD_ROUTINE(main_application_thread, data); /* Implementing thread table in which you add routines of your application and those provided by the SDK */ BEGIN_THREAD_TABLE THREAD_TABLE_ENTRY( main_application_thread, 20 ) END_THREAD_TABLE sem_t synchroSem; #define BLUE { printf("%s","\033[34;01m"); } #define RED { printf("%s","\033[31;01m"); } #define GREEN { printf("%s","\033[32;01m"); } #define RAZ { printf("%s","\033[0m"); } #define TEST_RESULT(result, formatFAIL, formatOK, ...) \ do \ { \ _ftp_status locResult = (result); \ totalOp++; \ if (FTP_FAILED (locResult)) \ { \ RED; \ printf ("[%i : KO] : ", __LINE__); \ printf (formatFAIL, __VA_ARGS__); \ printf ("\n"); \ RAZ; \ } \ else \ { \ GREEN; \ printf ("[%i : OK] : ", __LINE__); \ printf (formatOK, __VA_ARGS__); \ printf ("\n"); \ RAZ; \ opOk++; \ } \ if ((FTP_TIMEOUT == locResult) || \ (FTP_BUSY == locResult)) \ { \ runOperation = 1; \ } \ else \ { \ runOperation = 0; \ } \ } \ while (0) #define COMPUTE_PERCENT_OK \ do \ { \ if (totalOp> 0) \ { \ float percentOk = (100.0 * opOk) / (1.0 * totalOp); \ if (90.0 < percentOk) \ { \ GREEN; \ } \ else \ { \ RED; \ } \ printf ("Success of %llu operations on %llu (%6.2f %%)\n", opOk, totalOp, percentOk); \ RAZ; \ } \ } while (0) #define TEST_ABORTION(abortFunc) \ do \ { \ _ftp_status locStat = (abortFunc); \ totalOp++; \ switch (locStat) \ { \ case FTP_SUCCESS: \ GREEN; \ printf ("[%i : OK] : ", __LINE__); \ printf ("Abortion successfull\n"); \ RAZ; \ opOk++; \ break; \ case FTP_SAMESIZE: \ RED; \ printf ("[%i : KO] : ", __LINE__); \ printf ("Abortion failed, op was not running\n"); \ RAZ; \ break; \ case FTP_FAIL: \ default: \ RED; \ printf ("[%i : KO] : ", __LINE__); \ printf ("Unknown result\n"); \ RAZ; \ break; \ } \ } while (0) \ #define WAIT_COND(result) \ do \ { \ sem_wait (&synchroSem); \ } while (0) #define SEND_COND \ do \ { \ sem_post (&synchroSem); \ } \ while (0) _ftp_status globalStatus; int runOperation = 1; char *listBuffer = NULL; void ftpCallback (_ftp_status status, void *arg, _ftp_t *callingFtp) { float percent = (NULL != arg) ? *(float *)arg : -1.0; if (NULL != arg && FTP_SUCCESS == status) { listBuffer = arg; } globalStatus = status; static int calls = 0; #define CALLBACK_FORMAT "Callback called with status %s\n" #ifdef DEBUG #define PRINT_CALLBACK_FORMAT(statusString) { printf (CALLBACK_FORMAT, statusString); calls++; } #else #define PRINT_CALLBACK_FORMAT(statusString) { calls++; } #endif switch (status) { case FTP_BUSY: PRINT_CALLBACK_FORMAT ("FTP_BUSY"); SEND_COND; break; case FTP_ABORT: PRINT_CALLBACK_FORMAT ("FTP_ABORT"); SEND_COND; break; case FTP_FAIL: PRINT_CALLBACK_FORMAT ("FTP_FAIL"); SEND_COND; break; case FTP_SUCCESS: PRINT_CALLBACK_FORMAT ("FTP_SUCCESS"); SEND_COND; break; case FTP_TIMEOUT: PRINT_CALLBACK_FORMAT ("FTP_TIMEOUT"); SEND_COND; break; case FTP_BADSIZE: PRINT_CALLBACK_FORMAT ("FTP_BADSIZE"); SEND_COND; break; case FTP_SAMESIZE: PRINT_CALLBACK_FORMAT ("FTP_SAMESIZE"); SEND_COND; break; case FTP_PROGRESS: printf ("\rProgress : %5.2f", percent); fflush (stdout); if (100.0 <= percent) { printf ("\n"); } break; default: // Should not happen ... kill the program in this case ! printf ("Callback called with unknown status : %d\n", status); exit (-1); break; } #undef CALLBACK_FORMAT } #define title(x) { BLUE; printf("[%i] %s",__LINE__,x); RAZ; } #define ARDRONE_IP "192.168.1.1" #define ARDRONE_PORT (21) #define ARDRONE_USER "anonymous" #define ARDRONE_PASSWORD "" #define _1MB_ORIGIN_FILE "origin.txt" #define _512K_FAILED_FILE "half_file.txt" #define _256K_FAILED_FILE "quarter_file.txt" #define _1MB_MERGED_FILE "merged.txt" #define LOCAL_RESULT_FILE "result.txt" #define NOCB_NORESUME_RESULT "result_nocb_noresume.txt" #define CB_NORESUME_RESULT "result_cb_noresume.txt" #define NOCB_RESUME_RESULT "result_nocb_resume.txt" #define CB_RESUME_RESULT "result_cb_resume.txt" #define ARDRONE_FILE_BEFORE_RENAME "origin.txt" #define ARDRONE_FILE_AFTER_RENAME "result.txt" DEFINE_THREAD_ROUTINE(main_application_thread, data) { /* Semaphore for synchronisation */ sem_init (&synchroSem, 0, 0); vp_os_delay(1000); char buffer [512] = {0}; int systemRet = 0; _ftp_t *droneFtp = NULL; _ftp_status ftp_result = FTP_FAIL; int runOperation = 1; uint64_t totalOp = 0; uint64_t opOk = 0; title ("\n\n------ CLEANING ------\n\n"); title ("--- Connecting to AR.Drone FTP ---\n"); for (runOperation = 1; runOperation;) { droneFtp = ftpConnect (ARDRONE_IP, ARDRONE_PORT, ARDRONE_USER, ARDRONE_PASSWORD, &ftp_result); TEST_RESULT (ftp_result, "Unable to connect to %s@%s:%d (PASS : %s)", "Connected to %s@%s:%d (PASS : %s)", ARDRONE_USER, ARDRONE_IP, ARDRONE_PORT, ARDRONE_PASSWORD); } title ("--- Getting PWD ---\n"); char pwd [256] = {0}; ftp_result = ftpPwd (droneFtp, pwd, 256); TEST_RESULT (ftp_result, "Unable to get PWD [%1s]", "Got PWD : %s", pwd); title ("--- Removing previous file on AR.Drone ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpRemove (droneFtp, ARDRONE_FILE_BEFORE_RENAME); TEST_RESULT (ftp_result, " (STILL OK !) file %s does not exist", "Deleted file %s", ARDRONE_FILE_BEFORE_RENAME); } for (runOperation = 1; runOperation;) { ftp_result = ftpRemove (droneFtp, ARDRONE_FILE_AFTER_RENAME); TEST_RESULT (ftp_result, " (STILL OK !) file %s does not exist", "Deleted file %s", ARDRONE_FILE_AFTER_RENAME); } title ("--- Removing local result file ---\n"); vp_os_memset (buffer, 0x0, 512); snprintf (buffer, 512, "rm -f %s", LOCAL_RESULT_FILE); systemRet = system (buffer); printf ("System : %s\n", buffer); title ("--- Disconnecting from AR.Drone FTP ---\n"); TEST_RESULT (ftpClose (&droneFtp), "AR.Drone FTP (%s:%d) was not opened", "Closed AR.Drone FTP (%s:%d)", ARDRONE_IP, ARDRONE_PORT); while (1) { title ("\n\n------ TESTS WITHOUT RESUME NOR CALLBACK ------\n\n"); title ("--- Connecting to AR.Drone FTP ---\n"); for (runOperation = 1; runOperation;) { droneFtp = ftpConnect (ARDRONE_IP, ARDRONE_PORT, ARDRONE_USER, ARDRONE_PASSWORD, &ftp_result); TEST_RESULT (ftp_result, "Unable to connect to %s@%s:%d (PASS : %s)", "Connected to %s@%s:%d (PASS : %s)", ARDRONE_USER, ARDRONE_IP, ARDRONE_PORT, ARDRONE_PASSWORD); } title ("--- Sending origin file to the AR.Drone ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpPut (droneFtp, _1MB_ORIGIN_FILE, ARDRONE_FILE_BEFORE_RENAME, 0, NULL); TEST_RESULT (ftp_result, "Unable to send file %s->%s", "Sent file %s->%s", _1MB_ORIGIN_FILE, ARDRONE_FILE_BEFORE_RENAME); } title ("--- Renaming file on the AR.Drone ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpRename (droneFtp, ARDRONE_FILE_BEFORE_RENAME, ARDRONE_FILE_AFTER_RENAME); TEST_RESULT (ftp_result, "Impossible to rename %s->%s", "Renamed %s->%s", ARDRONE_FILE_BEFORE_RENAME, ARDRONE_FILE_AFTER_RENAME); } title ("--- Getting AR.Drone FTP Listing ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpList (droneFtp, &listBuffer, NULL); TEST_RESULT (ftp_result, "Unable to list FTP [%1s]", "Listed FTP :\n%s", listBuffer); if (NULL != listBuffer) { vp_os_free (listBuffer); listBuffer = NULL; } } title ("--- Getting back result file ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpGet (droneFtp, ARDRONE_FILE_AFTER_RENAME, LOCAL_RESULT_FILE, 0, NULL); TEST_RESULT (ftp_result, "Unable to get file %s->%s", "Got back file %s->%s", ARDRONE_FILE_AFTER_RENAME, LOCAL_RESULT_FILE); } title ("--- Checking file ---\n"); vp_os_memset (buffer, 0x0, 512); snprintf (buffer, 512, "diff %s %s > /dev/null", LOCAL_RESULT_FILE, _1MB_ORIGIN_FILE); systemRet = system (buffer); printf ("System : %s\n", buffer); totalOp++; if (0 != systemRet) { RED; printf ("[%d : KO] : Files are different !\n", __LINE__); RAZ; } else { opOk++; GREEN; printf ("[%d : OK] : Files are the same\n", __LINE__); RAZ; } title ("--- Removing file on AR.Drone ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpRemove (droneFtp, ARDRONE_FILE_AFTER_RENAME); TEST_RESULT (ftp_result, "Unable to delete file %s", "Deleted file %s", ARDRONE_FILE_AFTER_RENAME); } title ("--- Local file backup ---\n"); vp_os_memset (buffer, 0x0, 512); snprintf (buffer, 512, "mv %s %s", LOCAL_RESULT_FILE, NOCB_NORESUME_RESULT); systemRet = system (buffer); printf ("System : %s\n", buffer); title ("--- Closing AR.Drone FTP ---\n"); TEST_RESULT (ftpClose (&droneFtp), "AR.Drone FTP (%s:%d) was not opened", "Closed AR.Drone FTP (%s:%d)", ARDRONE_IP, ARDRONE_PORT); title ("\n\n------ TESTS WITHOUT RESUME / WITH CALLBACK ------\n\n"); title ("--- Connecting to AR.Drone FTP ---\n"); for (runOperation = 1; runOperation;) { droneFtp = ftpConnect (ARDRONE_IP, ARDRONE_PORT, ARDRONE_USER, ARDRONE_PASSWORD, &ftp_result); TEST_RESULT (ftp_result, "Unable to connect to %s@%s:%d (PASS : %s)", "Connected to %s@%s:%d (PASS : %s)", ARDRONE_USER, ARDRONE_IP, ARDRONE_PORT, ARDRONE_PASSWORD); } title ("--- Sending origin file to the AR.Drone ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpPut (droneFtp, _1MB_ORIGIN_FILE, ARDRONE_FILE_BEFORE_RENAME, 0, ftpCallback); WAIT_COND (ftp_result); TEST_RESULT (globalStatus, "Unable to send file %s->%s", "Sent file %s->%s", _1MB_ORIGIN_FILE, ARDRONE_FILE_BEFORE_RENAME); } title ("--- Renaming file on the AR.Drone ---\n"); ftp_result = ftpRename (droneFtp, ARDRONE_FILE_BEFORE_RENAME, ARDRONE_FILE_AFTER_RENAME); TEST_RESULT (ftp_result, "Impossible to rename %s->%s", "Renamed %s->%s", ARDRONE_FILE_BEFORE_RENAME, ARDRONE_FILE_AFTER_RENAME); title ("--- Getting AR.Drone FTP Listing ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpList (droneFtp, NULL, ftpCallback); WAIT_COND (ftp_result); TEST_RESULT (globalStatus, "Unable to list FTP [%1s]", "Listed FTP :\n%s", listBuffer); if (NULL != listBuffer) { vp_os_free (listBuffer); listBuffer = NULL; } } title ("--- Getting back result file ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpGet (droneFtp, ARDRONE_FILE_AFTER_RENAME, LOCAL_RESULT_FILE, 0, ftpCallback); WAIT_COND (ftp_result); TEST_RESULT (globalStatus, "Unable to get file %s->%s", "Got back file %s->%s", ARDRONE_FILE_AFTER_RENAME, LOCAL_RESULT_FILE); } title ("--- Checking file ---\n"); vp_os_memset (buffer, 0x0, 512); snprintf (buffer, 512, "diff %s %s > /dev/null", LOCAL_RESULT_FILE, _1MB_ORIGIN_FILE); systemRet = system (buffer); printf ("System : %s\n", buffer); totalOp++; if (0 != systemRet) { RED; printf ("[%d : KO] : Files are different !\n", __LINE__); RAZ; } else { opOk++; GREEN; printf ("[%d : OK] : Files are the same\n", __LINE__); RAZ; } title ("--- Removing file on AR.Drone ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpRemove (droneFtp, ARDRONE_FILE_AFTER_RENAME); TEST_RESULT (ftp_result, "Unable to delete file %s", "Deleted file %s", ARDRONE_FILE_AFTER_RENAME); } title ("--- Local file backup ---\n"); vp_os_memset (buffer, 0x0, 512); snprintf (buffer, 512, "mv %s %s", LOCAL_RESULT_FILE, CB_NORESUME_RESULT); systemRet = system (buffer); printf ("System : %s\n", buffer); title ("--- Closing AR.Drone FTP ---\n"); TEST_RESULT (ftpClose (&droneFtp), "AR.Drone FTP (%s:%d) was not opened", "Closed AR.Drone FTP (%s:%d)", ARDRONE_IP, ARDRONE_PORT); title ("\n\n------ TESTS WITH RESUME / NO CALLBACK ------\n\n"); title ("--- Preparing bad file (256K) locally ---\n"); vp_os_memset (buffer, 0x0, 512); snprintf (buffer, 512, "cp %s %s", _256K_FAILED_FILE, LOCAL_RESULT_FILE); systemRet = system (buffer); printf ("System : %s\n", buffer); title ("--- Connecting to AR.Drone FTP ---\n"); for (runOperation = 1; runOperation;) { droneFtp = ftpConnect (ARDRONE_IP, ARDRONE_PORT, ARDRONE_USER, ARDRONE_PASSWORD, &ftp_result); TEST_RESULT (ftp_result, "Unable to connect to %s@%s:%d (PASS : %s)", "Connected to %s@%s:%d (PASS : %s)", ARDRONE_USER, ARDRONE_IP, ARDRONE_PORT, ARDRONE_PASSWORD); } title ("--- Preparing bad file (512K) on AR.Drone FTP ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpPut (droneFtp, _512K_FAILED_FILE, ARDRONE_FILE_BEFORE_RENAME, 1, NULL); TEST_RESULT (ftp_result, "Unable to send partial file %s->%s", "Sent partial file %s->%s", _512K_FAILED_FILE, ARDRONE_FILE_BEFORE_RENAME); } title ("--- Sending origin file to the AR.Drone ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpPut (droneFtp, _1MB_ORIGIN_FILE, ARDRONE_FILE_BEFORE_RENAME, 1, NULL); TEST_RESULT (ftp_result, "Unable to send file %s->%s", "Sent file %s->%s", _1MB_ORIGIN_FILE, ARDRONE_FILE_BEFORE_RENAME); } title ("--- Renaming file on the AR.Drone ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpRename (droneFtp, ARDRONE_FILE_BEFORE_RENAME, ARDRONE_FILE_AFTER_RENAME); TEST_RESULT (ftp_result, "Impossible to rename %s->%s", "Renamed %s->%s", ARDRONE_FILE_BEFORE_RENAME, ARDRONE_FILE_AFTER_RENAME); } title ("--- Getting AR.Drone FTP Listing ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpList (droneFtp, &listBuffer, NULL); TEST_RESULT (ftp_result, "Unable to list FTP [%1s]", "Listed FTP :\n%s", listBuffer); if (NULL != listBuffer) { vp_os_free (listBuffer); listBuffer = NULL; } } title ("--- Getting back result file ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpGet (droneFtp, ARDRONE_FILE_AFTER_RENAME, LOCAL_RESULT_FILE, 1, NULL); TEST_RESULT (ftp_result, "Unable to get file %s->%s", "Got back file %s->%s", ARDRONE_FILE_AFTER_RENAME, LOCAL_RESULT_FILE); } title ("--- Checking file ---\n"); vp_os_memset (buffer, 0x0, 512); snprintf (buffer, 512, "diff %s %s > /dev/null", LOCAL_RESULT_FILE, _1MB_MERGED_FILE); systemRet = system (buffer); printf ("System : %s\n", buffer); totalOp++; if (0 != systemRet) { RED; printf ("[%d : KO] : Files are different !\n", __LINE__); RAZ; } else { opOk++; GREEN; printf ("[%d : OK] : Files are the same\n", __LINE__); RAZ; } title ("--- Removing file on AR.Drone ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpRemove (droneFtp, ARDRONE_FILE_AFTER_RENAME); TEST_RESULT (ftp_result, "Unable to delete file %s", "Deleted file %s", ARDRONE_FILE_AFTER_RENAME); } title ("--- Local file backup ---\n"); vp_os_memset (buffer, 0x0, 512); snprintf (buffer, 512, "mv %s %s", LOCAL_RESULT_FILE, NOCB_RESUME_RESULT); systemRet = system (buffer); printf ("System : %s\n", buffer); title ("--- Closing AR.Drone FTP ---\n"); TEST_RESULT (ftpClose (&droneFtp), "AR.Drone FTP (%s:%d) was not opened", "Closed AR.Drone FTP (%s:%d)", ARDRONE_IP, ARDRONE_PORT); title ("\n\n------ TESTS WITH RESUME AND CALLBACK ------\n\n"); title ("--- Preparing bad file (256K) locally ---\n"); vp_os_memset (buffer, 0x0, 512); snprintf (buffer, 512, "cp %s %s", _256K_FAILED_FILE, LOCAL_RESULT_FILE); systemRet = system (buffer); printf ("System : %s\n", buffer); title ("--- Connecting to AR.Drone FTP ---\n"); for (runOperation = 1; runOperation;) { droneFtp = ftpConnect (ARDRONE_IP, ARDRONE_PORT, ARDRONE_USER, ARDRONE_PASSWORD, &ftp_result); TEST_RESULT (ftp_result, "Unable to connect to %s@%s:%d (PASS : %s)", "Connected to %s@%s:%d (PASS : %s)", ARDRONE_USER, ARDRONE_IP, ARDRONE_PORT, ARDRONE_PASSWORD); } title ("--- Preparing bad file (512K) on AR.Drone FTP ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpPut (droneFtp, _512K_FAILED_FILE, ARDRONE_FILE_BEFORE_RENAME, 1, ftpCallback); WAIT_COND (ftp_result); TEST_RESULT (globalStatus, "Unable to send partial file %s->%s", "Sent partial file %s->%s", _512K_FAILED_FILE, ARDRONE_FILE_BEFORE_RENAME); } title ("--- Sending origin file to the AR.Drone ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpPut (droneFtp, _1MB_ORIGIN_FILE, ARDRONE_FILE_BEFORE_RENAME, 1, ftpCallback); WAIT_COND (ftp_result); TEST_RESULT (globalStatus, "Unable to send file %s->%s", "Sent file %s->%s", _1MB_ORIGIN_FILE, ARDRONE_FILE_BEFORE_RENAME); } title ("--- Renaming file on the AR.Drone ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpRename (droneFtp, ARDRONE_FILE_BEFORE_RENAME, ARDRONE_FILE_AFTER_RENAME); TEST_RESULT (ftp_result, "Impossible to rename %s->%s", "Renamed %s->%s", ARDRONE_FILE_BEFORE_RENAME, ARDRONE_FILE_AFTER_RENAME); } title ("--- Getting AR.Drone FTP Listing ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpList (droneFtp, NULL, ftpCallback); WAIT_COND (ftp_result); TEST_RESULT (globalStatus, "Unable to list FTP [%1s]", "Listed FTP :\n%s", listBuffer); if (NULL != listBuffer) { vp_os_free (listBuffer); listBuffer = NULL; } } title ("--- Getting back result file ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpGet (droneFtp, ARDRONE_FILE_AFTER_RENAME, LOCAL_RESULT_FILE, 1, ftpCallback); WAIT_COND (ftp_result); TEST_RESULT (globalStatus, "Unable to get file %s->%s", "Got back file %s->%s", ARDRONE_FILE_AFTER_RENAME, LOCAL_RESULT_FILE); } title ("--- Checking file ---\n"); vp_os_memset (buffer, 0x0, 512); snprintf (buffer, 512, "diff %s %s > /dev/null", LOCAL_RESULT_FILE, _1MB_MERGED_FILE); systemRet = system (buffer); printf ("System : %s\n", buffer); totalOp++; if (0 != systemRet) { RED; printf ("[%d : KO] : Files are different !\n", __LINE__); RAZ; } else { opOk++; GREEN; printf ("[%d : OK] : Files are the same\n", __LINE__); RAZ; } title ("--- Removing file on AR.Drone ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpRemove (droneFtp, ARDRONE_FILE_AFTER_RENAME); TEST_RESULT (ftp_result, "Unable to delete file %s", "Deleted file %s", ARDRONE_FILE_AFTER_RENAME); } title ("--- Local file backup ---\n"); vp_os_memset (buffer, 0x0, 512); snprintf (buffer, 512, "mv %s %s", LOCAL_RESULT_FILE, CB_RESUME_RESULT); systemRet = system (buffer); printf ("System : %s\n", buffer); title ("--- Closing AR.Drone FTP ---\n"); TEST_RESULT (ftpClose (&droneFtp), "AR.Drone FTP (%s:%d) was not opened", "Closed AR.Drone FTP (%s:%d)", ARDRONE_IP, ARDRONE_PORT); title ("\n\n------ ABORTION TESTS ------\n\n"); title ("--- Connecting to AR.Drone FTP ---\n"); for (runOperation = 1; runOperation;) { droneFtp = ftpConnect (ARDRONE_IP, ARDRONE_PORT, ARDRONE_USER, ARDRONE_PASSWORD, &ftp_result); TEST_RESULT (ftp_result, "Unable to connect to %s@%s:%d (PASS : %s)", "Connected to %s@%s:%d (PASS : %s)", ARDRONE_USER, ARDRONE_IP, ARDRONE_PORT, ARDRONE_PASSWORD); } title ("--- Sending origin file to the AR.Drone ... aborted ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpPut (droneFtp, _1MB_ORIGIN_FILE, ARDRONE_FILE_BEFORE_RENAME, 1, ftpCallback); usleep (500000); TEST_ABORTION (ftpAbort (droneFtp)); WAIT_COND (ftp_result); TEST_RESULT ((FTP_ABORT == globalStatus) ? FTP_SUCCESS : FTP_FAIL, "Impossible to abort %s->%s transfert", "Aborted %s->%s transfert", _1MB_ORIGIN_FILE, ARDRONE_FILE_BEFORE_RENAME); } title ("--- Sending origin file to the AR.Drone ... complete previous operation ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpPut (droneFtp, _1MB_ORIGIN_FILE, ARDRONE_FILE_BEFORE_RENAME, 1, ftpCallback); WAIT_COND (ftp_result); TEST_RESULT (globalStatus, "Unable to send file %s->%s", "Sent file %s->%s", _1MB_ORIGIN_FILE, ARDRONE_FILE_BEFORE_RENAME); } title ("--- Getting AR.Drone FTP Listing ... aborted ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpList (droneFtp, NULL, ftpCallback); usleep (1000); TEST_ABORTION (ftpAbort (droneFtp)); WAIT_COND (ftp_result); TEST_RESULT ((FTP_ABORT == globalStatus) ? FTP_SUCCESS : FTP_FAIL, "Impossible to abort %s", "Aborted %s", "listing"); if (NULL != listBuffer) { vp_os_free (listBuffer); listBuffer = NULL; } } title ("--- Getting AR.Drone FTP Listing ... ok ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpList (droneFtp, NULL, ftpCallback); WAIT_COND (ftp_result); TEST_RESULT (globalStatus, "Unable to list FTP [%1s]", "Listed FTP :\n%s", listBuffer); if (NULL != listBuffer) { vp_os_free (listBuffer); listBuffer = NULL; } } title ("--- Getting back origin file as result ... aborted ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpGet (droneFtp, ARDRONE_FILE_BEFORE_RENAME, LOCAL_RESULT_FILE, 1, ftpCallback); usleep (500000); TEST_ABORTION (ftpAbort (droneFtp)); WAIT_COND (ftp_result); TEST_RESULT ((FTP_ABORT == globalStatus) ? FTP_SUCCESS : FTP_FAIL, "Impossible to abort %s->%s transfert", "Aborted %s->%s transfert", ARDRONE_FILE_BEFORE_RENAME, LOCAL_RESULT_FILE); } title ("--- Getting back origin file as result ... complete previous operation ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpGet (droneFtp, ARDRONE_FILE_BEFORE_RENAME, LOCAL_RESULT_FILE, 1, ftpCallback); WAIT_COND (ftp_result); TEST_RESULT (globalStatus, "Unable to get file %s->%s", "Got back file %s->%s", ARDRONE_FILE_BEFORE_RENAME, LOCAL_RESULT_FILE); } title ("--- Checking file ---\n"); vp_os_memset (buffer, 0x0, 512); snprintf (buffer, 512, "diff %s %s > /dev/null", LOCAL_RESULT_FILE, _1MB_ORIGIN_FILE); systemRet = system (buffer); printf ("System : %s\n", buffer); totalOp++; if (0 != systemRet) { RED; printf ("[%d : KO] : Files are different !\n", __LINE__); RAZ; } else { opOk++; GREEN; printf ("[%d : OK] : Files are the same\n", __LINE__); RAZ; } title ("--- Removing file on AR.Drone ---\n"); for (runOperation = 1; runOperation;) { ftp_result = ftpRemove (droneFtp, ARDRONE_FILE_BEFORE_RENAME); TEST_RESULT (ftp_result, "Unable to delete file %s", "Deleted file %s", ARDRONE_FILE_BEFORE_RENAME); } title ("--- Closing AR.Drone FTP ---\n"); TEST_RESULT (ftpClose (&droneFtp), "AR.Drone FTP (%s:%d) was not opened", "Closed AR.Drone FTP (%s:%d)", ARDRONE_IP, ARDRONE_PORT); title ("\n\n------ RESULT ------\n\n"); COMPUTE_PERCENT_OK; } sem_destroy (&synchroSem); exit (0); return 0; }

kamilns@hotmail.com

08aecb4a9536aebf4aaf37b98cc367687a0c8365

eb7a1fb1c70fc82be0dfc0245255d5506433d156

/Microchip/SAMG_DFP/3.2.35/samg53/include/samg53n19.h

6fe2860ec312ae40a34b60f4ebcb58b456db212b

permissive

muthukrishnankarthik/dev_packs

c03f66ce3f32d34340c8053363121657a0a37474

60d97ca66b10c00b3c42430b0cf0b4ae7542f217

refs/heads/master

UTF-8

C

h

/** * \brief Header file for ATSAMG53N19 * * Copyright (c) 2019 Microchip Technology Inc. and its subsidiaries. * * Subject to your compliance with these terms, you may use Microchip software and any derivatives * exclusively with Microchip products. It is your responsibility to comply with third party license * terms applicable to your use of third party software (including open source software) that may * accompany Microchip software. * * THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, * APPLY TO THIS SOFTWARE, INCLUDING ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, AND * FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE, INCIDENTAL OR CONSEQUENTIAL * LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF * MICROCHIP HAS BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO THE FULLEST EXTENT * ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS IN ANY WAY RELATED TO THIS SOFTWARE WILL NOT * EXCEED THE AMOUNT OF FEES, IF ANY, THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE. * */ /* file generated from device description version 2019-12-16T02:52:00Z */ #ifndef _SAMG53N19_H_ #define _SAMG53N19_H_ // Header version uses Semantic Versioning 2.0.0 (https://semver.org/) #define HEADER_FORMAT_VERSION "2.0.0" #define HEADER_FORMAT_VERSION_MAJOR (2) #define HEADER_FORMAT_VERSION_MINOR (0) /** \addtogroup SAMG53N19_definitions SAMG53N19 definitions This file defines all structures and symbols for SAMG53N19: - registers and bitfields - peripheral base address - peripheral ID - PIO definitions * @{ */ #ifdef __cplusplus extern "C" { #endif #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) # include <stdint.h> #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ #if !defined(SKIP_INTEGER_LITERALS) # if defined(_U_) || defined(_L_) || defined(_UL_) # error "Integer Literals macros already defined elsewhere" # endif #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) /* Macros that deal with adding suffixes to integer literal constants for C/C++ */ # define _U_(x) (x ## U) /**< C code: Unsigned integer literal constant value */ # define _L_(x) (x ## L) /**< C code: Long integer literal constant value */ # define _UL_(x) (x ## UL) /**< C code: Unsigned Long integer literal constant value */ #else /* Assembler */ # define _U_(x) x /**< Assembler: Unsigned integer literal constant value */ # define _L_(x) x /**< Assembler: Long integer literal constant value */ # define _UL_(x) x /**< Assembler: Unsigned Long integer literal constant value */ #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ #endif /* SKIP_INTEGER_LITERALS */ /** @} end of Atmel Global Defines */ /* ************************************************************************** */ /* CMSIS DEFINITIONS FOR SAMG53N19 */ /* ************************************************************************** */ #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) /** Interrupt Number Definition */ typedef enum IRQn { /****** CORTEX-M4 Processor Exceptions Numbers ******************************/ Reset_IRQn = -15, /**< -15 Reset Vector, invoked on Power up and warm reset */ NonMaskableInt_IRQn = -14, /**< -14 Non maskable Interrupt, cannot be stopped or preempted */ HardFault_IRQn = -13, /**< -13 Hard Fault, all classes of Fault */ MemoryManagement_IRQn = -12, /**< -12 Memory Management, MPU mismatch, including Access Violation and No Match */ BusFault_IRQn = -11, /**< -11 Bus Fault, Pre-Fetch-, Memory Access Fault, other address/memory related Fault */ UsageFault_IRQn = -10, /**< -10 Usage Fault, i.e. Undef Instruction, Illegal State Transition */ SVCall_IRQn = -5, /**< -5 System Service Call via SVC instruction */ DebugMonitor_IRQn = -4, /**< -4 Debug Monitor */ PendSV_IRQn = -2, /**< -2 Pendable request for system service */ SysTick_IRQn = -1, /**< -1 System Tick Timer */ /****** SAMG53N19 specific Interrupt Numbers ***********************************/ SUPC_IRQn = 0, /**< 0 Supply Controller (SUPC) */ RSTC_IRQn = 1, /**< 1 Reset Controller (RSTC) */ RTC_IRQn = 2, /**< 2 Real-time Clock (RTC) */ RTT_IRQn = 3, /**< 3 Real-time Timer (RTT) */ WDT_IRQn = 4, /**< 4 Watchdog Timer (WDT) */ PMC_IRQn = 5, /**< 5 Power Management Controller (PMC) */ EFC_IRQn = 6, /**< 6 Embedded Flash Controller (EFC) */ UART0_IRQn = 8, /**< 8 Universal Asynchronous Receiver Transmitter (UART0) */ UART1_IRQn = 9, /**< 9 Universal Asynchronous Receiver Transmitter (UART1) */ PIOA_IRQn = 11, /**< 11 Parallel Input/Output Controller (PIOA) */ PIOB_IRQn = 12, /**< 12 Parallel Input/Output Controller (PIOB) */ PDMIC0_IRQn = 13, /**< 13 Pulse Density Modulation Interface Controller (PDMIC0) */ USART_IRQn = 14, /**< 14 Universal Synchronous Asynchronous Receiver Transmitter (USART) */ MEM2MEM_IRQn = 15, /**< 15 Memory to Memory (MEM2MEM) */ I2SC0_IRQn = 16, /**< 16 Inter-IC Sound Controller (I2SC0) */ I2SC1_IRQn = 17, /**< 17 Inter-IC Sound Controller (I2SC1) */ PDMIC1_IRQn = 18, /**< 18 Pulse Density Modulation Interface Controller (PDMIC1) */ TWI0_IRQn = 19, /**< 19 Two-wire Interface High Speed (TWI0) */ TWI1_IRQn = 20, /**< 20 Two-wire Interface (TWI1) */ SPI_IRQn = 21, /**< 21 Serial Peripheral Interface (SPI) */ TWI2_IRQn = 22, /**< 22 Two-wire Interface (TWI2) */ TC0_CH0_IRQn = 23, /**< 23 Timer/Counter 0 Channel 0 (TC0) */ TC0_CH1_IRQn = 24, /**< 24 Timer/Counter 0 Channel 1 (TC0) */ TC0_CH2_IRQn = 25, /**< 25 Timer/Counter 0 Channel 2 (TC0) */ TC1_CH0_IRQn = 26, /**< 26 Timer/Counter 1 Channel 0 (TC1) */ TC1_CH1_IRQn = 27, /**< 27 Timer/Counter 1 Channel 1 (TC1) */ TC1_CH2_IRQn = 28, /**< 28 Timer/Counter 1 Channel 2 (TC1) */ ADC_IRQn = 29, /**< 29 Analog-to-Digital Converter (ADC) */ PERIPH_MAX_IRQn = 29 /**< Max peripheral ID */ } IRQn_Type; #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) typedef struct _DeviceVectors { /* Stack pointer */ void* pvStack; /* Cortex-M handlers */ void* pfnReset_Handler; /* -15 Reset Vector, invoked on Power up and warm reset */ void* pfnNonMaskableInt_Handler; /* -14 Non maskable Interrupt, cannot be stopped or preempted */ void* pfnHardFault_Handler; /* -13 Hard Fault, all classes of Fault */ void* pfnMemoryManagement_Handler; /* -12 Memory Management, MPU mismatch, including Access Violation and No Match */ void* pfnBusFault_Handler; /* -11 Bus Fault, Pre-Fetch-, Memory Access Fault, other address/memory related Fault */ void* pfnUsageFault_Handler; /* -10 Usage Fault, i.e. Undef Instruction, Illegal State Transition */ void* pvReservedC9; void* pvReservedC8; void* pvReservedC7; void* pvReservedC6; void* pfnSVCall_Handler; /* -5 System Service Call via SVC instruction */ void* pfnDebugMonitor_Handler; /* -4 Debug Monitor */ void* pvReservedC3; void* pfnPendSV_Handler; /* -2 Pendable request for system service */ void* pfnSysTick_Handler; /* -1 System Tick Timer */ /* Peripheral handlers */ void* pfnSUPC_Handler; /* 0 Supply Controller (SUPC) */ void* pfnRSTC_Handler; /* 1 Reset Controller (RSTC) */ void* pfnRTC_Handler; /* 2 Real-time Clock (RTC) */ void* pfnRTT_Handler; /* 3 Real-time Timer (RTT) */ void* pfnWDT_Handler; /* 4 Watchdog Timer (WDT) */ void* pfnPMC_Handler; /* 5 Power Management Controller (PMC) */ void* pfnEFC_Handler; /* 6 Embedded Flash Controller (EFC) */ void* pvReserved7; void* pfnUART0_Handler; /* 8 Universal Asynchronous Receiver Transmitter (UART0) */ void* pfnUART1_Handler; /* 9 Universal Asynchronous Receiver Transmitter (UART1) */ void* pvReserved10; void* pfnPIOA_Handler; /* 11 Parallel Input/Output Controller (PIOA) */ void* pfnPIOB_Handler; /* 12 Parallel Input/Output Controller (PIOB) */ void* pfnPDMIC0_Handler; /* 13 Pulse Density Modulation Interface Controller (PDMIC0) */ void* pfnUSART_Handler; /* 14 Universal Synchronous Asynchronous Receiver Transmitter (USART) */ void* pfnMEM2MEM_Handler; /* 15 Memory to Memory (MEM2MEM) */ void* pfnI2SC0_Handler; /* 16 Inter-IC Sound Controller (I2SC0) */ void* pfnI2SC1_Handler; /* 17 Inter-IC Sound Controller (I2SC1) */ void* pfnPDMIC1_Handler; /* 18 Pulse Density Modulation Interface Controller (PDMIC1) */ void* pfnTWI0_Handler; /* 19 Two-wire Interface High Speed (TWI0) */ void* pfnTWI1_Handler; /* 20 Two-wire Interface (TWI1) */ void* pfnSPI_Handler; /* 21 Serial Peripheral Interface (SPI) */ void* pfnTWI2_Handler; /* 22 Two-wire Interface (TWI2) */ void* pfnTC0_CH0_Handler; /* 23 Timer/Counter 0 Channel 0 (TC0) */ void* pfnTC0_CH1_Handler; /* 24 Timer/Counter 0 Channel 1 (TC0) */ void* pfnTC0_CH2_Handler; /* 25 Timer/Counter 0 Channel 2 (TC0) */ void* pfnTC1_CH0_Handler; /* 26 Timer/Counter 1 Channel 0 (TC1) */ void* pfnTC1_CH1_Handler; /* 27 Timer/Counter 1 Channel 1 (TC1) */ void* pfnTC1_CH2_Handler; /* 28 Timer/Counter 1 Channel 2 (TC1) */ void* pfnADC_Handler; /* 29 Analog-to-Digital Converter (ADC) */ } DeviceVectors; /* Defines for Deprecated Interrupt and Exceptions handler names */ #define pfnMemManage_Handler pfnMemoryManagement_Handler /**< \deprecated Backward compatibility for ASF*/ #define pfnDebugMon_Handler pfnDebugMonitor_Handler /**< \deprecated Backward compatibility for ASF*/ #define pfnNMI_Handler pfnNonMaskableInt_Handler /**< \deprecated Backward compatibility for ASF*/ #define pfnSVC_Handler pfnSVCall_Handler /**< \deprecated Backward compatibility for ASF*/ #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) #if !defined DONT_USE_PREDEFINED_CORE_HANDLERS /* CORTEX-M4 exception handlers */ void Reset_Handler ( void ); void NonMaskableInt_Handler ( void ); void HardFault_Handler ( void ); void MemoryManagement_Handler ( void ); void BusFault_Handler ( void ); void UsageFault_Handler ( void ); void SVCall_Handler ( void ); void DebugMonitor_Handler ( void ); void PendSV_Handler ( void ); void SysTick_Handler ( void ); #endif /* DONT_USE_PREDEFINED_CORE_HANDLERS */ #if !defined DONT_USE_PREDEFINED_PERIPHERALS_HANDLERS /* Peripherals interrupt handlers */ void SUPC_Handler ( void ); void RSTC_Handler ( void ); void RTC_Handler ( void ); void RTT_Handler ( void ); void WDT_Handler ( void ); void PMC_Handler ( void ); void EFC_Handler ( void ); void UART0_Handler ( void ); void UART1_Handler ( void ); void PIOA_Handler ( void ); void PIOB_Handler ( void ); void PDMIC0_Handler ( void ); void USART_Handler ( void ); void MEM2MEM_Handler ( void ); void I2SC0_Handler ( void ); void I2SC1_Handler ( void ); void PDMIC1_Handler ( void ); void TWI0_Handler ( void ); void TWI1_Handler ( void ); void SPI_Handler ( void ); void TWI2_Handler ( void ); void TC0_CH0_Handler ( void ); void TC0_CH1_Handler ( void ); void TC0_CH2_Handler ( void ); void TC1_CH0_Handler ( void ); void TC1_CH1_Handler ( void ); void TC1_CH2_Handler ( void ); void ADC_Handler ( void ); #endif /* DONT_USE_PREDEFINED_PERIPHERALS_HANDLERS */ /* Defines for Deprecated Interrupt and Exceptions handler names */ #define MemManage_Handler MemoryManagement_Handler /**< \deprecated Backward compatibility*/ #define DebugMon_Handler DebugMonitor_Handler /**< \deprecated Backward compatibility*/ #define NMI_Handler NonMaskableInt_Handler /**< \deprecated Backward compatibility*/ #define SVC_Handler SVCall_Handler /**< \deprecated Backward compatibility*/ #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ /* * \brief Configuration of the CORTEX-M4 Processor and Core Peripherals */ #define __CM4_REV 0x0001 /**< CM4 Core Revision */ #define __NVIC_PRIO_BITS 4 /**< Number of Bits used for Priority Levels */ #define __Vendor_SysTickConfig 0 /**< Set to 1 if different SysTick Config is used */ #define __MPU_PRESENT 1 /**< MPU present or not */ #define __VTOR_PRESENT 1 /**< Vector Table Offset Register present or not */ #define __FPU_PRESENT 1 /**< FPU present or not */ #define __ARCH_ARM 1 #define __ARCH_ARM_CORTEX_M 1 #define __DEVICE_IS_SAM 1 /* * \brief CMSIS includes */ #include "core_cm4.h" #if defined USE_CMSIS_INIT #include "system_samg53.h" #endif /* USE_CMSIS_INIT */ /** \defgroup SAMG53N19_api Peripheral Software API * @{ */ /* ************************************************************************** */ /** SOFTWARE PERIPHERAL API DEFINITION FOR SAMG53N19 */ /* ************************************************************************** */ #include "component/adc.h" #include "component/chipid.h" #include "component/efc.h" #include "component/gpbr.h" #include "component/i2sc.h" #include "component/matrix.h" #include "component/mem2mem.h" #include "component/pdc.h" #include "component/pdmic.h" #include "component/pio.h" #include "component/pmc.h" #include "component/rstc.h" #include "component/rtc.h" #include "component/rtt.h" #include "component/spi.h" #include "component/supc.h" #include "component/tc.h" #include "component/twi.h" #include "component/twihs.h" #include "component/uart.h" #include "component/usart.h" #include "component/wdt.h" /** @} end of Peripheral Software API */ /** \addtogroup SAMG53N19_id Peripheral Ids Definitions * @{ */ /* ************************************************************************** */ /* PERIPHERAL ID DEFINITIONS FOR SAMG53N19 */ /* ************************************************************************** */ #define ID_SUPC ( 0) /**< \brief Supply Controller (SUPC) */ #define ID_RSTC ( 1) /**< \brief Reset Controller (RSTC) */ #define ID_RTC ( 2) /**< \brief Real-time Clock (RTC) */ #define ID_RTT ( 3) /**< \brief Real-time Timer (RTT) */ #define ID_WDT ( 4) /**< \brief Watchdog Timer (WDT) */ #define ID_PMC ( 5) /**< \brief Power Management Controller (PMC) */ #define ID_EFC ( 6) /**< \brief Embedded Flash Controller (EFC) */ #define ID_UART0 ( 8) /**< \brief Universal Asynchronous Receiver Transmitter (UART0) */ #define ID_UART1 ( 9) /**< \brief Universal Asynchronous Receiver Transmitter (UART1) */ #define ID_PIOA ( 11) /**< \brief Parallel Input/Output Controller (PIOA) */ #define ID_PIOB ( 12) /**< \brief Parallel Input/Output Controller (PIOB) */ #define ID_PDMIC0 ( 13) /**< \brief Pulse Density Modulation Interface Controller (PDMIC0) */ #define ID_USART ( 14) /**< \brief Universal Synchronous Asynchronous Receiver Transmitter (USART) */ #define ID_MEM2MEM ( 15) /**< \brief Memory to Memory (MEM2MEM) */ #define ID_I2SC0 ( 16) /**< \brief Inter-IC Sound Controller (I2SC0) */ #define ID_I2SC1 ( 17) /**< \brief Inter-IC Sound Controller (I2SC1) */ #define ID_PDMIC1 ( 18) /**< \brief Pulse Density Modulation Interface Controller (PDMIC1) */ #define ID_TWI0 ( 19) /**< \brief Two-wire Interface High Speed (TWI0) */ #define ID_TWI1 ( 20) /**< \brief Two-wire Interface (TWI1) */ #define ID_SPI ( 21) /**< \brief Serial Peripheral Interface (SPI) */ #define ID_TWI2 ( 22) /**< \brief Two-wire Interface (TWI2) */ #define ID_TC0_CHANNEL0 ( 23) /**< \brief Timer Counter (TC0_CHANNEL0) */ #define ID_TC0_CHANNEL1 ( 24) /**< \brief Timer Counter (TC0_CHANNEL1) */ #define ID_TC0_CHANNEL2 ( 25) /**< \brief Timer Counter (TC0_CHANNEL2) */ #define ID_TC1_CHANNEL0 ( 26) /**< \brief Timer Counter (TC1_CHANNEL0) */ #define ID_TC1_CHANNEL1 ( 27) /**< \brief Timer Counter (TC1_CHANNEL1) */ #define ID_TC1_CHANNEL2 ( 28) /**< \brief Timer Counter (TC1_CHANNEL2) */ #define ID_ADC ( 29) /**< \brief Analog-to-Digital Converter (ADC) */ #define ID_PERIPH_MAX ( 29) /**< \brief Number of peripheral IDs */ /** @} end of Peripheral Ids Definitions */ /** \addtogroup SAMG53N19_base Peripheral Base Address Definitions * @{ */ /* ************************************************************************** */ /* REGISTER STRUCTURE ADDRESS DEFINITIONS FOR SAMG53N19 */ /* ************************************************************************** */ #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) #define ADC_REGS ((adc_registers_t*)0x40038000) /**< \brief ADC Registers Address */ #define CHIPID_REGS ((chipid_registers_t*)0x400e0740) /**< \brief CHIPID Registers Address */ #define EFC_REGS ((efc_registers_t*)0x400e0a00) /**< \brief EFC Registers Address */ #define GPBR_REGS ((gpbr_registers_t*)0x400e1490) /**< \brief GPBR Registers Address */ #define I2SC0_REGS ((i2sc_registers_t*)0x40000000) /**< \brief I2SC0 Registers Address */ #define I2SC1_REGS ((i2sc_registers_t*)0x40004000) /**< \brief I2SC1 Registers Address */ #define MATRIX_REGS ((matrix_registers_t*)0x400e0200) /**< \brief MATRIX Registers Address */ #define MEM2MEM_REGS ((mem2mem_registers_t*)0x40028000) /**< \brief MEM2MEM Registers Address */ #define PDMIC0_REGS ((pdmic_registers_t*)0x4002c000) /**< \brief PDMIC0 Registers Address */ #define PDMIC1_REGS ((pdmic_registers_t*)0x40030000) /**< \brief PDMIC1 Registers Address */ #define PIOA_REGS ((pio_registers_t*)0x400e0e00) /**< \brief PIOA Registers Address */ #define PIOB_REGS ((pio_registers_t*)0x400e1000) /**< \brief PIOB Registers Address */ #define PMC_REGS ((pmc_registers_t*)0x400e0400) /**< \brief PMC Registers Address */ #define RSTC_REGS ((rstc_registers_t*)0x400e1400) /**< \brief RSTC Registers Address */ #define RTC_REGS ((rtc_registers_t*)0x400e1460) /**< \brief RTC Registers Address */ #define RTT_REGS ((rtt_registers_t*)0x400e1430) /**< \brief RTT Registers Address */ #define SPI_REGS ((spi_registers_t*)0x40008000) /**< \brief SPI Registers Address */ #define SUPC_REGS ((supc_registers_t*)0x400e1410) /**< \brief SUPC Registers Address */ #define TC0_REGS ((tc_registers_t*)0x40010000) /**< \brief TC0 Registers Address */ #define TC1_REGS ((tc_registers_t*)0x40014000) /**< \brief TC1 Registers Address */ #define TWI1_REGS ((twi_registers_t*)0x4001c000) /**< \brief TWI1 Registers Address */ #define TWI2_REGS ((twi_registers_t*)0x40040000) /**< \brief TWI2 Registers Address */ #define TWI0_REGS ((twihs_registers_t*)0x40018000) /**< \brief TWI0 Registers Address */ #define UART0_REGS ((uart_registers_t*)0x400e0600) /**< \brief UART0 Registers Address */ #define UART1_REGS ((uart_registers_t*)0x400e0800) /**< \brief UART1 Registers Address */ #define USART_REGS ((usart_registers_t*)0x40024000) /**< \brief USART Registers Address */ #define WDT_REGS ((wdt_registers_t*)0x400e1450) /**< \brief WDT Registers Address */ #endif /* (defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ /** @} end of Peripheral Base Address Definitions */ /** \addtogroup SAMG53N19_base Peripheral Base Address Definitions * @{ */ /* ************************************************************************** */ /* BASE ADDRESS DEFINITIONS FOR SAMG53N19 */ /* ************************************************************************** */ #define ADC_BASE_ADDRESS _UL_(0x40038000) /**< \brief ADC Base Address */ #define CHIPID_BASE_ADDRESS _UL_(0x400e0740) /**< \brief CHIPID Base Address */ #define EFC_BASE_ADDRESS _UL_(0x400e0a00) /**< \brief EFC Base Address */ #define GPBR_BASE_ADDRESS _UL_(0x400e1490) /**< \brief GPBR Base Address */ #define I2SC0_BASE_ADDRESS _UL_(0x40000000) /**< \brief I2SC0 Base Address */ #define I2SC1_BASE_ADDRESS _UL_(0x40004000) /**< \brief I2SC1 Base Address */ #define MATRIX_BASE_ADDRESS _UL_(0x400e0200) /**< \brief MATRIX Base Address */ #define MEM2MEM_BASE_ADDRESS _UL_(0x40028000) /**< \brief MEM2MEM Base Address */ #define PDMIC0_BASE_ADDRESS _UL_(0x4002c000) /**< \brief PDMIC0 Base Address */ #define PDMIC1_BASE_ADDRESS _UL_(0x40030000) /**< \brief PDMIC1 Base Address */ #define PIOA_BASE_ADDRESS _UL_(0x400e0e00) /**< \brief PIOA Base Address */ #define PIOB_BASE_ADDRESS _UL_(0x400e1000) /**< \brief PIOB Base Address */ #define PMC_BASE_ADDRESS _UL_(0x400e0400) /**< \brief PMC Base Address */ #define RSTC_BASE_ADDRESS _UL_(0x400e1400) /**< \brief RSTC Base Address */ #define RTC_BASE_ADDRESS _UL_(0x400e1460) /**< \brief RTC Base Address */ #define RTT_BASE_ADDRESS _UL_(0x400e1430) /**< \brief RTT Base Address */ #define SPI_BASE_ADDRESS _UL_(0x40008000) /**< \brief SPI Base Address */ #define SUPC_BASE_ADDRESS _UL_(0x400e1410) /**< \brief SUPC Base Address */ #define TC0_BASE_ADDRESS _UL_(0x40010000) /**< \brief TC0 Base Address */ #define TC1_BASE_ADDRESS _UL_(0x40014000) /**< \brief TC1 Base Address */ #define TWI1_BASE_ADDRESS _UL_(0x4001c000) /**< \brief TWI1 Base Address */ #define TWI2_BASE_ADDRESS _UL_(0x40040000) /**< \brief TWI2 Base Address */ #define TWI0_BASE_ADDRESS _UL_(0x40018000) /**< \brief TWI0 Base Address */ #define UART0_BASE_ADDRESS _UL_(0x400e0600) /**< \brief UART0 Base Address */ #define UART1_BASE_ADDRESS _UL_(0x400e0800) /**< \brief UART1 Base Address */ #define USART_BASE_ADDRESS _UL_(0x40024000) /**< \brief USART Base Address */ #define WDT_BASE_ADDRESS _UL_(0x400e1450) /**< \brief WDT Base Address */ /** @} end of Peripheral Base Address Definitions */ /** \addtogroup SAMG53N19_pio Peripheral Pio Definitions * @{ */ /* ************************************************************************** */ /* PIO DEFINITIONS FOR SAMG53N19 */ /* ************************************************************************** */ #include "pio/samg53n19.h" /** @} end of Peripheral Pio Definitions */ /* ************************************************************************** */ /* MEMORY MAPPING DEFINITIONS FOR SAMG53N19 */ /* ************************************************************************** */ #define PERIPHERALS_SIZE _UL_(0x20000000) /* 524288kB Memory segment type: io */ #define SYSTEM_SIZE _UL_(0x10000000) /* 262144kB Memory segment type: io */ #define IFLASH_SIZE _UL_(0x00080000) /* 512kB Memory segment type: flash */ #define IFLASH_PAGE_SIZE _UL_( 512) #define IFLASH_NB_OF_PAGES _UL_( 1024) #define IROM_SIZE _UL_(0x00400000) /* 4096kB Memory segment type: rom */ #define IRAM_SIZE _UL_(0x00018000) /* 96kB Memory segment type: ram */ #define PERIPHERALS_ADDR _UL_(0x40000000) /**< PERIPHERALS base address (type: io)*/ #define SYSTEM_ADDR _UL_(0xe0000000) /**< SYSTEM base address (type: io)*/ #define IFLASH_ADDR _UL_(0x00400000) /**< IFLASH base address (type: flash)*/ #define IROM_ADDR _UL_(0x00800000) /**< IROM base address (type: rom)*/ #define IRAM_ADDR _UL_(0x20000000) /**< IRAM base address (type: ram)*/ /* ************************************************************************** */ /** DEVICE SIGNATURES FOR SAMG53N19 */ /* ************************************************************************** */ #define CHIP_JTAGID _UL_(0X05B3C03F) #define CHIP_CIDR _UL_(0X247E0AE8) #define CHIP_EXID _UL_(0X00000000) /* ************************************************************************** */ /** ELECTRICAL DEFINITIONS FOR SAMG53N19 */ /* ************************************************************************** */ #define CHIP_FREQ_SLCK_RC_MIN _UL_(20000) #define CHIP_FREQ_SLCK_RC _UL_(32000) /**< \brief Typical Slow Clock Internal RC frequency */ #define CHIP_FREQ_SLCK_RC_MAX _UL_(44000) #define CHIP_FREQ_MAINCK_RC_8MHZ _UL_(8000000) #define CHIP_FREQ_MAINCK_RC_16MHZ _UL_(16000000) #define CHIP_FREQ_MAINCK_RC_24MHZ _UL_(24000000) #define CHIP_FREQ_CPU_MAX _UL_(48000000) #define CHIP_FREQ_XTAL_32K _UL_(32768) #define CHIP_FLASH_WRITE_WAIT_STATE _UL_(6) /**< \brief Embedded Flash Write Wait State */ #define CHIP_FREQ_FWS_0 _UL_(12000000) /**< \brief Maximum operating frequency when FWS is 0 */ #define CHIP_FREQ_FWS_1 _UL_(25000000) /**< \brief Maximum operating frequency when FWS is 1 */ #define CHIP_FREQ_FWS_2 _UL_(38000000) /**< \brief Maximum operating frequency when FWS is 2 */ #define CHIP_FREQ_FWS_3 _UL_(48000000) /**< \brief Maximum operating frequency when FWS is 3 */ #define CHIP_FREQ_FWS_NUMBER _UL_(4) /**< \brief Number of FWS ranges */ #ifdef __cplusplus } #endif /** @} end of SAMG53N19 definitions */ #endif /* _SAMG53N19_H_ */

thibaut.viard@microchip.com

6ac15295a92c8a12a0c975af81dbd9a355096001

4c518f3a393e8a436dd75ceede72cc8eacd3e797

/abc.c

03c4af0f798ffdd70177dc44501711b3bfd60c1f

no_license

aartigodase1998/AssignmentDemo

dc852189fdcd39b8462ce6ca156243f91d4d943a

d63d7fdf7584d5e32cbe982187e50e6f36f9f19b

refs/heads/master

UTF-8

C

c

#include<stdio.h> void main() { int i; int n=5; for(i=0;i<10;i++) { printf("i value is %d",i); } for(i=1;i<=10;i++) { printf("\n %d",i*n); } }

arati.godase@ibm.com

c410186aaa272cd6625a38f8e698df7b7265309d

09f63e43bb01fb1803584cd4774f07bddbb21d25

/Windows/stdafx.h

a427989b1d5faf40799d03d8192c87f3bd7d0d02

no_license

KatekovAnton/wwiseIntegrationDemo

74ab0d5302e9d09c689db0f6798798c0af6fe01e

70caeb323919076e5ca66dde1bdbfb2063da9551

refs/heads/master

UTF-8

C

h

/******************************************************************************* The content of this file includes portions of the AUDIOKINETIC Wwise Technology released in source code form as part of the SDK installer package. Commercial License Usage Licensees holding valid commercial licenses to the AUDIOKINETIC Wwise Technology may use this file in accordance with the end user license agreement provided with the software or, alternatively, in accordance with the terms contained in a written agreement between you and Audiokinetic Inc. Version: v2019.1.1 Build: 6977 Copyright (c) 2006-2019 Audiokinetic Inc. *******************************************************************************/ // stdafx.h /// \file /// Precompiled Header File for the Integration Demo application. #pragma once //////////////////////////////////////////// // Helper Includes //////////////////////////////////////////// #include <AK/SoundEngine/Common/AkTypes.h> #include <AK/Tools/Common/AkPlatformFuncs.h> #define WIN32_LEAN_AND_MEAN #define DIRECTINPUT_VERSION 0x0800 #if defined(_MSC_VER) && (_MSC_VER < 1900) #define snprintf _snprintf #endif #include <windows.h> #include <dinput.h> #include <xinput.h> #include <d3d9.h> #include <D3dx9core.h> #include <wchar.h>

void0main@gmail.com

b6e8634221cb4319c3532a60dc30f6d8f8b006a1

accbe82b976125427a864937a3b5d57e2c90ddcf

/09/ex10/main.c

3b9461b37ab9379d1fdcf9ef9a1ba7225019b754

no_license

simdax/42correc

861882cf9efebfad6266f819ed5a585832984e2b

6e9af8980f74e48a945f61c7e51679b86e9a7f65

refs/heads/master

UTF-8

C

c

#include <limits.h> #include <stdio.h> #include <stdlib.h> #include <string.h> void ft_scrambler(int ***a, int *b, int *******c, int ****d); int main() { int nb = 1; int nb1 = 2; int nb2 = 3; int nb3 = 4; int *pnb0 = &nb; int **pnb01 = &pnb0; int ***pnb02 = &pnb01; int *pnb1 = &nb2; int **pnb11 = &pnb1; int ***pnb12 = &pnb11; int ****pnb13 = &pnb12; int *****pnb14 = &pnb13; int ******pnb15 = &pnb14; int *******pnb16 = &pnb15; int *pnb2 = &nb3; int **pnb21 = &pnb2; int ***pnb22 = &pnb21; int ****pnb23 = &pnb22; int *pnb3 = &nb1; ft_scrambler(pnb02, pnb3, pnb16, pnb23); printf("%d et %d et %d et %d", nb, nb1, nb2, nb3); return (0); }

scornaz@e2r5p7.42.fr

4c458e2fec5c9fcf895977fb1c22fc4accdef9a2

6f3e0000993816afa03d64c5a02b94fca2931200

/sys/arch/amiga/dev/viewioctl.h

f1c075c8281de3e8628c8a572886e40a90191061

no_license

fallen/NetBSD6

b6dc7a2593846816b8cb6f47cf26054ca2811667

44e0ac4ada812ace1f9ca8ce4792e287d83bd951

refs/heads/master

UTF-8

C

h

/* $NetBSD: viewioctl.h,v 1.9 2002/09/06 13:19:18 gehenna Exp $ */ /* * Copyright (c) 1994 Christian E. Hopps * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Christian E. Hopps. * 4. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* * The view major device is a placeholder device. It serves * simply to map the semantics of a graphics dipslay to * the semantics of a character block device. In other * words the graphics system as currently built does not like to be * refered to by open/close/ioctl. This device serves as * a interface to graphics. */ struct view_size { int x; int y; u_int width; u_int height; u_int depth; }; #define VIOCREMOVE _IO('V', 0x0) /* if displaying remove. */ #define VIOCDISPLAY _IO('V', 0x1) /* if not displaying, display */ #define VIOCSSIZE _IOW('V', 0x2, struct view_size) #define VIOCGSIZE _IOR('V', 0x3, struct view_size) #define VIOCGBMAP _IOR('V', 0x4, bmap_t) #define VIOCSCMAP _IOW('V', 0x5, colormap_t) #define VIOCGCMAP _IOWR('V', 0x6, colormap_t) #ifdef _KERNEL void viewprobe(void); #endif

yann.sionneau@gmail.com

f2ddd405c80a7469f4b5a0b544f63369a81d3848

c461a81314c3ae909c734a1736f90894344ff006

/temp/util69.c

a2a0952d8ab4e62627e1cfdb17d610e9a58f115d

no_license

flarss/many

3e85ea139fc702ba4561942ac8bee6a520839f57

a671f2fec22cde015f3bccf0bbd9eef345225de7

refs/heads/master

UTF-8

C

c

#include "inc6.h" #include <stdio.h> #include "inc61.h" #include "inc62.h" #include "inc63.h" #include "inc64.h" #include "inc65.h" #include "inc66.h" #include "inc67.h" #include "inc68.h" #include "inc69.h" void util69() { printf("util69 was here\n"); }

fredrikgit@gmail.com

885767f5ed2f17df19164d9915b241118b43e746

ea09f69660a8982a94c15adf66bdc99531b4b8aa

/0x0D-preprocessor/3-function_like_macro.h

d1f7f2ae20be34fd19be81d0c13622ce7b90d75d

no_license

gorgyboy/holbertonschool-low_level_programming

96ff91a00c4373ca77b513a6ba81fa78b6a4374f

ac3660f83e207417ff2a01f0992f14f2bd998515

refs/heads/master

UTF-8

C

h

#ifndef FLM_H #define FLM_H #define ABS(x) (((x) < 0) ? ((x) * -1) : (x)) #endif /* FLM_H */

jlrogb@gmail.com

fc2f2fc3f3ab5920563455ebe43d334e723b728c

af7c753cfbc9309e1276d12e2e29fbbd6d7602ce

/Firmware/ESP8266/Clay_ESP8266EX_Firmware/user/Message.c

22acdc922d747c3a6b001c8467ec576401269790

permissive

zzrgenius/Clay

b179c64f2348449f6766ba356af5daecf90639e5

31a84237d09eb93affb9b2587ff1d5b9a2b8c6a6

refs/heads/master

UTF-8

C

c

#include "stdlib.h" #include "stdint.h" #include "stdio.h" #include "string.h" #include "Message.h" #include "CRC16.h" #define DEFAULT_UUID_LENGTH 37 char messageUuidBuffer[DEFAULT_UUID_LENGTH] = { 0 }; char grammarSymbolBuffer[MAXIMUM_GRAMMAR_SYMBOL_LENGTH] = { 0 }; Message* Create_Message() { // Allocate memory for message structure. Message *message = (Message *) malloc(sizeof(Message)); (*message).message_type = NULL; (*message).source = NULL; (*message).destination = NULL; (*message).content_length = 0; (*message).content_checksum = 0; (*message).content_type = NULL; (*message).content = NULL; // Set up links for queue (*message).previous = NULL; (*message).next = NULL; return message; } int8_t Delete_Message(Message *message) { if (message != NULL) { // TODO: Remove references to the message in the queue. if ((*message).message_type != NULL) { free((*message).message_type); (*message).message_type = NULL; } if ((*message).source != NULL) { free((*message).source); (*message).source = NULL; } if ((*message).destination != NULL) { free((*message).destination); (*message).destination = NULL; } if ((*message).content_type != NULL) { free((*message).content_type); (*message).content_type = NULL; } if ((*message).content != NULL) { free((*message).content); (*message).content = NULL; } free(message); message = NULL; return true; } return false; } void Set_Message_Type(Message *message, const char *type) { // Free the message's destination stored type from memory if ((*message).message_type != NULL) { free((*message).message_type); (*message).message_type = NULL; } // Copy the type into the structure (*message).message_type = (char *) zalloc(strlen(type) + 1); memset((*message).message_type, '\0', strlen(type) + 1); strcpy((*message).message_type, type); } void Set_Message_Source(Message *message, const char *address) { // Free the message's destination address from memory if ((*message).source != NULL) { free((*message).source); (*message).source = NULL; } // Copy the message destination address (*message).source = (char *) zalloc(strlen(address) + 1); memset((*message).source, '\0', strlen(address) + 1); strcpy((*message).source, address); } void Set_Message_Destination(Message *message, const char *address) { // Free the message's destination address from memory if ((*message).destination != NULL) { free((*message).destination); (*message).destination = NULL; } // Copy the message destination address (*message).destination = (char *) zalloc(strlen(address) + 1); memset((*message).destination, '\0', strlen(address) + 1); strcpy((*message).destination, address); } void Set_Message_Content(Message * message, const char *content, uint32_t content_length) { if ((*message).content != NULL) { free((*message).content); (*message).content = NULL; (*message).content_length = 0; (*message).content_checksum = 0; } (*message).content_length = content_length; // Allocate memory for the message's content. (*message).content = (char *) malloc((*message).content_length + 1); (*message).content_checksum = Calculate_Checksum_On_Bytes(content, content_length); memset((*message).content, 0, (*message).content_length + 1); // Copy message content memcpy((*message).content, content, (*message).content_length); } extern void Set_Message_Content_Type(Message *message, const char *content_type) { // Free the message's destination address from memory if ((*message).content_type != NULL) { free((*message).content_type); (*message).content_type = NULL; } // Copy the message content_type address (*message).content_type = (char *) malloc(strlen(content_type) + 1); memset((*message).content_type, '\0', strlen(content_type) + 1); strcpy((*message).content_type, content_type); } char * Get_Message_Type(Message *message) { return (*message).message_type; } char * Get_Message_Source(Message *message) { return (*message).source; } char * Get_Message_Destination(Message *message) { return (*message).destination; } char * Get_Message_Content(Message *message) { return (*message).content; } uint32_t Get_Message_Content_Length(Message *message) { return (*message).content_length; } char * Get_Message_Content_Type(Message *message) { return (*message).message_type; }

thebhef@gmail.com

a56523d691f882861f8034e7160307fc7fd860c8

409e10d2e57f7a3ee7c5a8c03320df0cef990d39

/移动距离/src/移动距离.c

d04b23b232c8dd43f24087e8327bc68b233dff6c

no_license

asdlei99/SomeOjCode-CXX

7f437ed041ee984d5abd7b10b0d433f4b759b99c

bc7253f8534184fac748f28f9c93ecbb09e0906f

refs/heads/master

UTF-8

C

c

/* ============================================================================ Name : 移动距离.c Author : Version : Copyright : Your copyright notice Description : Hello World in C, Ansi-style ============================================================================ */ #include <stdio.h> #include <stdlib.h> #define N 100 int main(void) { int n, a, b; scanf("%d%d%d", &n, &a, &b); int arr[N / n][n]; for (int i = 0; i < N / n; i++) { for (int j = 0; j < n; j++) { if (i % 2 == 0) arr[i][j] = i * n + j + 1; else arr[i][j] = (i + 1) * n - j; } } int x1, y1, x2, y2; for (int i = 0; i < N / n; i++) { for (int j = 0; j < n; j++) { if (a == arr[i][j]) { x1 = i; y1 = j; } if (b == arr[i][j]) { x2 = i; y2 = j; } } } printf("%d",abs(x2-x1)+abs(y2-y1)); return EXIT_SUCCESS; }

imqqyangfan@gmail.com

a0e3a07a3dae566c5a995ecd3772ef4caf72a311

440fe9bc55a3d9fc44410d1748f47fbc74e30506

/anycloud39ev300/SDK/component/UVC_check_sensor/component/drvlib/include/randomizer.h

7f768eb96d869a227d1c1a8c4e627985959e8a51

no_license

haihoang1219931/qiwen

5def7764f48e70a8c4fbb9692f5fd0714dcb5a20

6c86facd09a5c2efe5314a669f653fa90acbc999

refs/heads/main

UTF-8

C

h

/** * @filename randomizer.h * @brief the arithmetic to randomize or derandomize the data * Copyright (C) 2006 Anyka (Guangzhou) Software Technology Co., LTD * @author yangyiming * @date 2012-05-15 * @version 1.0 */ #ifndef __RANDOMIZER_H_ #define __RANDOMIZER_H_ #define MALLOC drv_malloc /** *@brief initial the randomizer * *@author yangyiming *@date 2012-05-15 *@param PageSize[in] the pagesize of the nand *@return bool true for success, false for failure */ bool randomizer_init(unsigned long PageSize); /** *@brief randomize the data or derandomize the randomized data * *@author yangyiming *@date 2012-05-15 *@param pageIndex[in] the offset of the page where the data got from /will be stored in the nand *@param EccFrameIndex[in] which ecc frame in a page *@param destBuff[out] the buffer to store the data to be converted *@param srcBuff[in] the buffer stored the data to be converted *@param datalen[in] the data length ,unit byte *@return void */ void randomize(unsigned long pageIndex, unsigned long EccFrameIndex, unsigned char *destBuff,unsigned char *srcBuff, unsigned long datalen); #endif

1397610152@qq.com

59756cdc7478a47f4c2393d8d2fc18e6c812af5b

d0c4232f57b408e9d4de4813a28e0b4396772d05

/gems/gems/libxml-ruby-0.9.4/ext/libxml/ruby_xml_document.c

467b3a069fd8e594e2bec5592a4c5555d7585916

permissive

larssg/group-shelf

8a154feb39a820b66411d54a25f4d066cd87b894

fa1a0156c62b9ea3694180ba415bacc77a3cabb9

refs/heads/master

UTF-8

C

c

/* $Id: ruby_xml_document.c 626 2008-11-22 20:47:07Z cfis $ */ /* * Document-class: LibXML::XML::Document * * The XML::Document class provides a tree based API for working * with xml documents. You may directly create a document and * manipulate it, or create a document from a data source by * using an XML::Parser object. * * To create a document from scratch: * * doc = XML::Document.new() * doc.root = XML::Node.new('root_node') * doc.root << XML::Node.new('elem1') * doc.save('output.xml', format) * * To read a document from a file: * * doc = XML::Document.file('my_file') * * To use a parser to read a document: * * parser = XML::Parser.new * parser.file = 'my_file' * doc = parser.parse * * To write a file: * * * doc = XML::Document.new() * doc.root = XML::Node.new('root_node') * root = doc.root * * root << elem1 = XML::Node.new('elem1') * elem1['attr1'] = 'val1' * elem1['attr2'] = 'val2' * * root << elem2 = XML::Node.new('elem2') * elem2['attr1'] = 'val1' * elem2['attr2'] = 'val2' * * root << elem3 = XML::Node.new('elem3') * elem3 << elem4 = XML::Node.new('elem4') * elem3 << elem5 = XML::Node.new('elem5') * * elem5 << elem6 = XML::Node.new('elem6') * elem6 << 'Content for element 6' * * elem3['attr'] = 'baz' * * format = true * doc.save('output.xml', format) */ #include <stdarg.h> #include <st.h> #include "ruby_libxml.h" #include "ruby_xml_document.h" VALUE cXMLDocument; void rxml_document_free(xmlDocPtr xdoc) { xdoc->_private = NULL; xmlFreeDoc(xdoc); } void rxml_document_mark(xmlDocPtr xdoc) { rb_gc_mark(LIBXML_STATE); } VALUE rxml_document_wrap(xmlDocPtr xdoc) { VALUE result; // This node is already wrapped if (xdoc->_private != NULL) { result = (VALUE)xdoc->_private; } else { result = Data_Wrap_Struct(cXMLDocument, rxml_document_mark, rxml_document_free, xdoc); xdoc->_private = (void*)result; } return result; } /* * call-seq: * XML::Document.alloc(xml_version = 1.0) -> document * * Alocates a new XML::Document, optionally specifying the * XML version. */ static VALUE rxml_document_alloc(VALUE klass) { return Data_Wrap_Struct(klass, rxml_document_mark, rxml_document_free, NULL); } /* * call-seq: * XML::Document.initialize(xml_version = 1.0) -> document * * Initializes a new XML::Document, optionally specifying the * XML version. */ static VALUE rxml_document_initialize(int argc, VALUE *argv, VALUE self) { xmlDocPtr xdoc; VALUE xmlver; switch (argc) { case 0: xmlver = rb_str_new2("1.0"); break; case 1: rb_scan_args(argc, argv, "01", &xmlver); break; default: rb_raise(rb_eArgError, "wrong number of arguments (need 0 or 1)"); } Check_Type(xmlver, T_STRING); xdoc = xmlNewDoc((xmlChar*)StringValuePtr(xmlver)); xdoc->_private = (void*)self; DATA_PTR(self) = xdoc; return self; } /* * call-seq: * document.compression -> num * * Obtain this document's compression mode identifier. */ static VALUE rxml_document_compression_get(VALUE self) { #ifdef HAVE_ZLIB_H xmlDocPtr xdoc; int compmode; Data_Get_Struct(self, xmlDoc, xdoc); compmode = xmlGetDocCompressMode(xdoc); if (compmode == -1) return(Qnil); else return(INT2NUM(compmode)); #else rb_warn("libxml not compiled with zlib support"); return(Qfalse); #endif } /* * call-seq: * document.compression = num * * Set this document's compression mode. */ static VALUE rxml_document_compression_set(VALUE self, VALUE num) { #ifdef HAVE_ZLIB_H xmlDocPtr xdoc; int compmode; Check_Type(num, T_FIXNUM); Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc == NULL) { return(Qnil); } else { xmlSetDocCompressMode(xdoc, NUM2INT(num)); compmode = xmlGetDocCompressMode(xdoc); if (compmode == -1) return(Qnil); else return(INT2NUM(compmode)); } #else rb_warn("libxml compiled without zlib support"); return(Qfalse); #endif } /* * call-seq: * document.compression? -> (true|false) * * Determine whether this document is compressed. */ static VALUE rxml_document_compression_q(VALUE self) { #ifdef HAVE_ZLIB_H xmlDocPtr xdoc; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc->compression != -1) return(Qtrue); else return(Qfalse); #else rb_warn("libxml compiled without zlib support"); return(Qfalse); #endif } /* * call-seq: * document.child -> node * * Get this document's child node. */ static VALUE rxml_document_child_get(VALUE self) { xmlDocPtr xdoc; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc->children == NULL) return(Qnil); return rxml_node2_wrap(cXMLNode, xdoc->children); } /* * call-seq: * document.child? -> (true|false) * * Determine whether this document has a child node. */ static VALUE rxml_document_child_q(VALUE self) { xmlDocPtr xdoc; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc->children == NULL) return(Qfalse); else return(Qtrue); } /* * call-seq: * document.dump([stream]) -> true * * Dump this document's XML to the specified IO stream. * If no stream is specified, stdout is used. */ static VALUE rxml_document_dump(int argc, VALUE *argv, VALUE self) { OpenFile *fptr; VALUE io; FILE *out; xmlDocPtr xdoc; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc == NULL) return(Qnil); switch (argc) { case 0: io = rb_stdout; break; case 1: io = argv[0]; if (!rb_obj_is_kind_of(io, rb_cIO)) rb_raise(rb_eTypeError, "need an IO object"); break; default: rb_raise(rb_eArgError, "wrong number of arguments (0 or 1)"); } GetOpenFile(io, fptr); rb_io_check_writable(fptr); out = GetWriteFile(fptr); xmlDocDump(out, xdoc); return(Qtrue); } /* * call-seq: * document.debug_dump([stream]) -> true * * Debug version of dump. */ static VALUE rxml_document_debug_dump(int argc, VALUE *argv, VALUE self) { #ifdef LIBXML_DEBUG_ENABLED OpenFile *fptr; VALUE io; FILE *out; xmlDocPtr xdoc; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc == NULL) return(Qnil); switch (argc) { case 0: io = rb_stderr; break; case 1: io = argv[0]; if (!rb_obj_is_kind_of(io, rb_cIO)) rb_raise(rb_eTypeError, "need an IO object"); break; default: rb_raise(rb_eArgError, "wrong number of arguments (0 or 1)"); } GetOpenFile(io, fptr); rb_io_check_writable(fptr); out = GetWriteFile(fptr); xmlDebugDumpDocument(out, xdoc); return(Qtrue); #else rb_warn("libxml was compiled without debugging support. Please recompile libxml and ruby-libxml"); return(Qfalse); #endif } /* * call-seq: * document.debug_dump_head([stream]) -> true * * Debug-dump this document's header to the specified IO stream. * If no stream is specified, stdout is used. */ static VALUE rxml_document_debug_dump_head(int argc, VALUE *argv, VALUE self) { #ifdef LIBXML_DEBUG_ENABLED OpenFile *fptr; VALUE io; FILE *out; xmlDocPtr xdoc; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc == NULL) return(Qnil); switch (argc) { case 0: io = rb_stdout; break; case 1: io = argv[0]; if (!rb_obj_is_kind_of(io, rb_cIO)) rb_raise(rb_eTypeError, "need an IO object"); break; default: rb_raise(rb_eArgError, "wrong number of arguments (0 or 1)"); } GetOpenFile(io, fptr); rb_io_check_writable(fptr); out = GetWriteFile(fptr); xmlDebugDumpDocumentHead(out, xdoc); return(Qtrue); #else rb_warn("libxml was compiled without debugging support. Please recompile libxml and ruby-libxml"); return(Qfalse); #endif } /* * call-seq: * document.format_dump([stream], [spacing]) -> true * * Dump this document's formatted XML to the specified IO stream. * If no stream is specified, stdout is used. If spacing is * specified, it must be a boolean that determines whether * spacing is used. */ static VALUE rxml_document_format_dump(int argc, VALUE *argv, VALUE self) { OpenFile *fptr; VALUE bool, io; FILE *out; xmlDocPtr xdoc; int size, spacing; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc == NULL) return(Qnil); switch (argc) { case 0: io = rb_stdout; spacing = 1; break; case 1: io = argv[0]; if (!rb_obj_is_kind_of(io, rb_cIO)) rb_raise(rb_eTypeError, "need an IO object"); spacing = 1; break; case 2: io = argv[0]; if (!rb_obj_is_kind_of(io, rb_cIO)) rb_raise(rb_eTypeError, "need an IO object"); bool = argv[1]; if (TYPE(bool) == T_TRUE) spacing = 1; else if (TYPE(bool) == T_FALSE) spacing = 0; else rb_raise(rb_eTypeError, "incorect argument type, second argument must be bool"); break; default: rb_raise(rb_eArgError, "wrong number of arguments (0 or 1)"); } GetOpenFile(io, fptr); rb_io_check_writable(fptr); out = GetWriteFile(fptr); size = xmlDocFormatDump(out, xdoc, spacing); return(INT2NUM(size)); } /* * call-seq: * document.debug_format_dump([stream]) -> true * * *Deprecated* in favour of format_dump. */ static VALUE rxml_document_debug_format_dump(int argc, VALUE *argv, VALUE self) { rb_warn("debug_format_dump has been deprecaited, use format_dump instead"); return(rxml_document_format_dump(argc, argv, self)); } /* * call-seq: * document.encoding -> "encoding" * * Obtain the encoding specified by this document. */ static VALUE rxml_document_encoding_get(VALUE self) { xmlDocPtr xdoc; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc->encoding == NULL) return(Qnil); else return(rb_str_new2((const char*)xdoc->encoding)); } /* * call-seq: * document.encoding = "encoding" * * Set the encoding for this document. */ static VALUE rxml_document_encoding_set(VALUE self, VALUE encoding) { xmlDocPtr xdoc; Check_Type(encoding, T_STRING); Data_Get_Struct(self, xmlDoc, xdoc); xdoc->encoding = xmlStrdup(StringValuePtr(encoding)); return(rxml_document_encoding_get(self)); } /* * call-seq: * document.last -> node * * Obtain the last node. */ static VALUE rxml_document_last_get(VALUE self) { xmlDocPtr xdoc; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc->last == NULL) return(Qnil); return rxml_node2_wrap(cXMLNode, xdoc->last); } /* * call-seq: * document.last? -> (true|false) * * Determine whether there is a last node. */ static VALUE rxml_document_last_q(VALUE self) { xmlDocPtr xdoc; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc->last == NULL) return(Qfalse); else return(Qtrue); } /* * call-seq: * document.next -> node * * Obtain the next node. */ static VALUE rxml_document_next_get(VALUE self) { xmlDocPtr xdoc; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc->next == NULL) return(Qnil); return rxml_node2_wrap(cXMLNode, xdoc->next); } /* * call-seq: * document.next? -> (true|false) * * Determine whether there is a next node. */ static VALUE rxml_document_next_q(VALUE self) { xmlDocPtr xdoc; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc->next == NULL) return(Qfalse); else return(Qtrue); } /* * call-seq: * document.parent -> node * * Obtain the parent node. */ static VALUE rxml_document_parent_get(VALUE self) { xmlDocPtr xdoc; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc->parent == NULL) return(Qnil); return rxml_node2_wrap(cXMLNode, xdoc->parent); } /* * call-seq: * document.parent? -> (true|false) * * Determine whether there is a parent node. */ static VALUE rxml_document_parent_q(VALUE self) { xmlDocPtr xdoc; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc->parent == NULL) return(Qfalse); else return(Qtrue); } /* * call-seq: * document.prev -> node * * Obtain the previous node. */ static VALUE rxml_document_prev_get(VALUE self) { xmlDocPtr xdoc; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc->prev == NULL) return(Qnil); return rxml_node2_wrap(cXMLNode, xdoc->prev); } /* * call-seq: * document.prev? -> (true|false) * * Determine whether there is a previous node. */ static VALUE rxml_document_prev_q(VALUE self) { xmlDocPtr xdoc; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc->prev == NULL) return(Qfalse); else return(Qtrue); } /* * call-seq: * document.root -> node * * Obtain the root node. */ static VALUE rxml_document_root_get(VALUE self) { xmlDocPtr xdoc; xmlNodePtr root; Data_Get_Struct(self, xmlDoc, xdoc); root = xmlDocGetRootElement(xdoc); if (root == NULL) return(Qnil); return rxml_node2_wrap(cXMLNode, root); } /* * call-seq: * document.root = node * * Set the root node. */ static VALUE rxml_document_root_set(VALUE self, VALUE node) { xmlDocPtr xdoc; xmlNodePtr xroot, xnode; if (rb_obj_is_kind_of(node, cXMLNode) == Qfalse) rb_raise(rb_eTypeError, "must pass an XML::Node type object"); Data_Get_Struct(self, xmlDoc, xdoc); Data_Get_Struct(node, xmlNode, xnode); xroot = xmlDocSetRootElement(xdoc, xnode); if (xroot == NULL) return(Qnil); return rxml_node2_wrap(cXMLNode, xroot); } /* * call-seq: * document.save(filename, format = false) -> int * * Save this document to the file given by filename, * optionally formatting the output. * Parameters: * filename: The filename or URL of the new document * format: Specifies whether formatting spaces should be added. * returns: The number of bytes written or -1 in case of error. */ static VALUE rxml_document_save(int argc, VALUE *argv, VALUE self) { xmlDocPtr xdoc; const char *filename; int format = 0; int len; if (argc <1 || argc > 2) rb_raise(rb_eArgError, "wrong number of arguments (need 1 or 2)"); Check_Type(argv[0], T_STRING); filename = StringValuePtr(argv[0]); if (argc == 2) { switch (TYPE(argv[1])) { case T_TRUE: format = 1; break; case T_FALSE: format = 0; break; default: rb_raise(rb_eArgError, "The second parameter (format) must be true or false"); } } Data_Get_Struct(self, xmlDoc, xdoc); len = xmlSaveFormatFileEnc(filename, xdoc, (const char*)xdoc->encoding, format); if (len == -1) rb_raise(rb_eIOError, "Could not write document"); else return(INT2NUM(len)); } /* * call-seq: * document.standalone? -> (true|false) * * Determine whether this is a standalone document. */ static VALUE rxml_document_standalone_q(VALUE self) { xmlDocPtr xdoc; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc->standalone) return(Qtrue); else return(Qfalse); } /* * call-seq: * document.to_s({format=true,encoding) -> "xml" * * Coerce this document to a string representation * of it's XML. The default is to pretty format, but this * depends Parser#indent_tree_output==true or * Parser#default_keep_blanks==false. * * The encoding is not applied to the document, but is * encoding target of the resulting string. */ static VALUE rxml_document_to_s(int argc, VALUE *argv, VALUE self) { xmlDocPtr xdoc; xmlChar *result, *encoding=NULL; int format, len; VALUE rresult; switch (argc) { case 0: format = 1; break; case 2: if (TYPE(argv[1]) == T_STRING) encoding=(xmlChar *)StringValuePtr(argv[1]); case 1: if (TYPE(argv[0]) == T_TRUE) format = 1; else if (TYPE(argv[0]) == T_FALSE) format = 0; else rb_raise(rb_eTypeError, "wrong type of argument, must be bool"); break; default: rb_raise(rb_eArgError, "wrong number of arguments (0 or 1)"); } Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc == NULL) { return(Qnil); } else if (encoding != NULL) { if (format) { xmlDocDumpFormatMemoryEnc(xdoc, &result, &len, (const char*)encoding, format); } else { xmlDocDumpMemoryEnc(xdoc, &result, &len, (const char *)encoding); } } else { if (format) xmlDocDumpFormatMemory(xdoc, &result, &len, format); else xmlDocDumpMemory(xdoc, &result, &len); } rresult=rb_str_new((const char*)result,len); xmlFree(result); return rresult; } /* * call-seq: * document.url -> "url" * * Obtain this document's source URL, if any. */ static VALUE rxml_document_url_get(VALUE self) { xmlDocPtr xdoc; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc->URL == NULL) return(Qnil); else return(rb_str_new2((const char*)xdoc->URL)); } /* * call-seq: * document.version -> "version" * * Obtain the XML version specified by this document. */ static VALUE rxml_document_version_get(VALUE self) { xmlDocPtr xdoc; Data_Get_Struct(self, xmlDoc, xdoc); if (xdoc->version == NULL) return(Qnil); else return(rb_str_new2((const char*)xdoc->version)); } /* * call-seq: * document.xinclude -> num * * Process xinclude directives in this document. */ static VALUE rxml_document_xinclude(VALUE self) { #ifdef LIBXML_XINCLUDE_ENABLED xmlDocPtr xdoc; int ret; Data_Get_Struct(self, xmlDoc, xdoc); ret = xmlXIncludeProcess(xdoc); if (ret >= 0) { return(INT2NUM(ret)); } else { rxml_raise(&xmlLastError); return Qnil; } #else rb_warn("libxml was compiled without XInclude support. Please recompile libxml and ruby-libxml"); return(Qfalse); #endif } void LibXML_validity_error(void * ctxt, const char * msg, va_list ap) { if (rb_block_given_p()) { char buff[1024]; snprintf(buff, 1024, msg, ap); rb_yield(rb_ary_new3(2, rb_str_new2(buff), Qtrue)); } else { fprintf(stderr, "error -- found validity error: "); fprintf(stderr, msg, ap); } } void LibXML_validity_warning(void * ctxt, const char * msg, va_list ap) { if (rb_block_given_p()) { char buff[1024]; snprintf(buff, 1024, msg, ap); rb_yield(rb_ary_new3(2, rb_str_new2(buff), Qfalse)); } else { fprintf(stderr, "warning -- found validity error: "); fprintf(stderr, msg, ap); } } /* * call-seq: * document.validate_schema(schema) -> (true|false) * * Validate this document against the specified XML::Schema. * * If a block is provided it is used as an error handler for validaten errors. * The block is called with two argument, the message and a flag indication * if the message is an error (true) or a warning (false). */ static VALUE rxml_document_validate_schema(VALUE self, VALUE schema) { xmlSchemaValidCtxtPtr vptr; xmlDocPtr xdoc; xmlSchemaPtr xschema; int is_invalid; Data_Get_Struct(self, xmlDoc, xdoc); Data_Get_Struct(schema, xmlSchema, xschema); vptr = xmlSchemaNewValidCtxt(xschema); xmlSchemaSetValidErrors(vptr, (xmlSchemaValidityErrorFunc)LibXML_validity_error, (xmlSchemaValidityWarningFunc)LibXML_validity_warning, NULL); is_invalid = xmlSchemaValidateDoc(vptr, xdoc); xmlSchemaFreeValidCtxt(vptr); if (is_invalid) { rxml_raise(&xmlLastError); return Qfalse; } else { return Qtrue; } } /* * call-seq: * document.validate_schema(relaxng) -> (true|false) * * Validate this document against the specified XML::RelaxNG. * * If a block is provided it is used as an error handler for validaten errors. * The block is called with two argument, the message and a flag indication * if the message is an error (true) or a warning (false). */ static VALUE rxml_document_validate_relaxng(VALUE self, VALUE relaxng) { xmlRelaxNGValidCtxtPtr vptr; xmlDocPtr xdoc; xmlRelaxNGPtr xrelaxng; int is_invalid; Data_Get_Struct(self, xmlDoc, xdoc); Data_Get_Struct(relaxng, xmlRelaxNG, xrelaxng); vptr = xmlRelaxNGNewValidCtxt(xrelaxng); xmlRelaxNGSetValidErrors(vptr, (xmlRelaxNGValidityErrorFunc)LibXML_validity_error, (xmlRelaxNGValidityWarningFunc)LibXML_validity_warning, NULL); is_invalid = xmlRelaxNGValidateDoc(vptr, xdoc); xmlRelaxNGFreeValidCtxt(vptr); if (is_invalid) { rxml_raise(&xmlLastError); return Qfalse; } else { return Qtrue; } } /* * call-seq: * document.validate(dtd) -> (true|false) * * Validate this document against the specified XML::DTD. */ static VALUE rxml_document_validate_dtd(VALUE self, VALUE dtd) { VALUE error = Qnil; xmlValidCtxt ctxt; xmlDocPtr xdoc; xmlDtdPtr xdtd; Data_Get_Struct(self, xmlDoc, xdoc); Data_Get_Struct(dtd, xmlDtd, xdtd); ctxt.userData = &error; ctxt.error = (xmlValidityErrorFunc)LibXML_validity_error; ctxt.warning = (xmlValidityWarningFunc)LibXML_validity_warning; ctxt.nodeNr = 0; ctxt.nodeTab = NULL; ctxt.vstateNr = 0; ctxt.vstateTab = NULL; if (xmlValidateDtd(&ctxt, xdoc, xdtd)) { return(Qtrue); } else { rxml_raise(&xmlLastError); return Qfalse; } } /* * call-seq: * document.reader -> reader * * Create a XML::Reader from the document. This is a shortcut to * XML::Reader.walker(). */ static VALUE rxml_document_reader(VALUE self) { return rxml_reader_new_walker(cXMLReader, self); } // Rdoc needs to know #ifdef RDOC_NEVER_DEFINED mLibXML = rb_define_module("LibXML"); mXML = rb_define_module_under(mLibXML, "XML"); #endif void ruby_init_xml_document(void) { cXMLDocument = rb_define_class_under(mXML, "Document", rb_cObject); rb_define_alloc_func(cXMLDocument, rxml_document_alloc); rb_define_method(cXMLDocument, "initialize", rxml_document_initialize, -1); rb_define_method(cXMLDocument, "child", rxml_document_child_get, 0); rb_define_method(cXMLDocument, "child?", rxml_document_child_q, 0); rb_define_method(cXMLDocument, "compression", rxml_document_compression_get, 0); rb_define_method(cXMLDocument, "compression=", rxml_document_compression_set, 1); rb_define_method(cXMLDocument, "compression?", rxml_document_compression_q, 0); rb_define_method(cXMLDocument, "dump", rxml_document_dump, -1); rb_define_method(cXMLDocument, "debug_dump", rxml_document_debug_dump, -1); rb_define_method(cXMLDocument, "debug_dump_head", rxml_document_debug_dump_head, -1); rb_define_method(cXMLDocument, "debug_format_dump", rxml_document_debug_format_dump, -1); rb_define_method(cXMLDocument, "encoding", rxml_document_encoding_get, 0); rb_define_method(cXMLDocument, "encoding=", rxml_document_encoding_set, 1); rb_define_method(cXMLDocument, "format_dump", rxml_document_format_dump, -1); rb_define_method(cXMLDocument, "last", rxml_document_last_get, 0); rb_define_method(cXMLDocument, "last?", rxml_document_last_q, 0); rb_define_method(cXMLDocument, "next", rxml_document_next_get, 0); rb_define_method(cXMLDocument, "next?", rxml_document_next_q, 0); rb_define_method(cXMLDocument, "parent", rxml_document_parent_get, 0); rb_define_method(cXMLDocument, "parent?", rxml_document_parent_q, 0); rb_define_method(cXMLDocument, "prev", rxml_document_prev_get, 0); rb_define_method(cXMLDocument, "prev?", rxml_document_prev_q, 0); rb_define_method(cXMLDocument, "root", rxml_document_root_get, 0); rb_define_method(cXMLDocument, "root=", rxml_document_root_set, 1); rb_define_method(cXMLDocument, "save", rxml_document_save, -1); rb_define_method(cXMLDocument, "standalone?", rxml_document_standalone_q, 0); rb_define_method(cXMLDocument, "to_s", rxml_document_to_s, -1); rb_define_method(cXMLDocument, "url", rxml_document_url_get, 0); rb_define_method(cXMLDocument, "version", rxml_document_version_get, 0); rb_define_method(cXMLDocument, "xinclude", rxml_document_xinclude, 0); rb_define_method(cXMLDocument, "validate", rxml_document_validate_dtd, 1); rb_define_method(cXMLDocument, "validate_schema", rxml_document_validate_schema, 1); rb_define_method(cXMLDocument, "validate_relaxng", rxml_document_validate_relaxng, 1); rb_define_method(cXMLDocument, "reader", rxml_document_reader, 0); }

lgs@lenio.dk

db2a78e09b1a1fcb258316b2a2245c63fc704a22

91d42e36516668992e7df8b63823392601f07cb8

/CommonTools/test/plotSyst_ch6.C

0e6eefe3e4f19198f517de495b06aaf5b99fc4c3

no_license

senka/CombinedEWKAnalysis_shapeVSlnN_debug

9e0a04876792c236782cfd1769d0719ff8d7694c

35925317281eb2c7d841dd2c7fb1415037644e3e

refs/heads/master

UTF-8

C

c

void plotSyst_ch6(){ TFile * file_in=new TFile("../data/WV_semileptonic/ch6_boosted.root","read"); file_in->cd(); zz2l2nu ->SetFillColor(0); zz2l2nu_CMS_eff_bUp ->SetFillColor(0); zz2l2nu_CMS_hzz2l2v_QCD_ACC_JVetoUp ->SetFillColor(0); zz2l2nu_CMS_hzz2l2v_lesUp ->SetFillColor(0); zz2l2nu_CMS_hzz2l2v_puUp ->SetFillColor(0); zz2l2nu_CMS_hzz2l2v_stat_ll_zz2l2nu_8TeVUp ->SetFillColor(0); zz2l2nu_CMS_hzz2l2v_umetUp ->SetFillColor(0); zz2l2nu_CMS_res_jUp ->SetFillColor(0); zz2l2nu_CMS_scale_jUp ->SetFillColor(0); zz2l2nu_CMS_hzz2l2v_sherpaUp ->SetFillColor(0); zz2l2nu_CMS_eff_bDown ->SetFillColor(0); zz2l2nu_CMS_hzz2l2v_QCD_ACC_JVetoDown ->SetFillColor(0); zz2l2nu_CMS_hzz2l2v_lesDown ->SetFillColor(0); zz2l2nu_CMS_hzz2l2v_puDown ->SetFillColor(0); zz2l2nu_CMS_hzz2l2v_stat_ll_zz2l2nu_8TeVDown ->SetFillColor(0); zz2l2nu_CMS_hzz2l2v_umetDown ->SetFillColor(0); zz2l2nu_CMS_res_jDown ->SetFillColor(0); zz2l2nu_CMS_scale_jDown ->SetFillColor(0); zz2l2nu_CMS_hzz2l2v_sherpaDown ->SetFillColor(0); wz3lnu ->SetFillColor(0); wz3lnu_CMS_eff_bUp ->SetFillColor(0); wz3lnu_CMS_hzz2l2v_lesUp ->SetFillColor(0); wz3lnu_CMS_hzz2l2v_puUp ->SetFillColor(0); wz3lnu_CMS_hzz2l2v_stat_ll_wz3lnu_8TeVUp ->SetFillColor(0); wz3lnu_CMS_hzz2l2v_umetUp ->SetFillColor(0); wz3lnu_CMS_res_jUp ->SetFillColor(0); wz3lnu_CMS_scale_jUp ->SetFillColor(0); wz3lnu_CMS_eff_bDown ->SetFillColor(0); wz3lnu_CMS_hzz2l2v_lesDown ->SetFillColor(0); wz3lnu_CMS_hzz2l2v_puDown ->SetFillColor(0); wz3lnu_CMS_hzz2l2v_stat_ll_wz3lnu_8TeVDown ->SetFillColor(0); wz3lnu_CMS_hzz2l2v_umetDown ->SetFillColor(0); wz3lnu_CMS_res_jDown ->SetFillColor(0); wz3lnu_CMS_scale_jDown ->SetFillColor(0); zll ->SetFillColor(0); zll_CMS_hzz2l2v_stat_ll_zll_8TeVUp ->SetFillColor(0); zll_CMS_hzz2l2v_stat_ll_zll_8TeVDown ->SetFillColor(0); topwwwjetsdata ->SetFillColor(0); topwwwjetsdata_CMS_hzz2l2v_stat_ll_topwwwjetsdata_8TeVUp ->SetFillColor(0); topwwwjetsdata_CMS_hzz2l2v_stat_ll_topwwwjetsdata_8TeVDown ->SetFillColor(0); data_obs ->SetFillColor(0); zz2l2nu_CMS_eff_bUp ->SetLineColor(2); zz2l2nu_CMS_hzz2l2v_QCD_ACC_JVetoUp ->SetLineColor(2); zz2l2nu_CMS_hzz2l2v_lesUp ->SetLineColor(2); zz2l2nu_CMS_hzz2l2v_puUp ->SetLineColor(2); zz2l2nu_CMS_hzz2l2v_stat_ll_zz2l2nu_8TeVUp ->SetLineColor(2); zz2l2nu_CMS_hzz2l2v_umetUp ->SetLineColor(2); zz2l2nu_CMS_res_jUp ->SetLineColor(2); zz2l2nu_CMS_scale_jUp ->SetLineColor(2); zz2l2nu_CMS_hzz2l2v_sherpaUp ->SetLineColor(2); wz3lnu_CMS_eff_bUp ->SetLineColor(2); wz3lnu_CMS_hzz2l2v_lesUp ->SetLineColor(2); wz3lnu_CMS_hzz2l2v_puUp ->SetLineColor(2); wz3lnu_CMS_hzz2l2v_stat_ll_wz3lnu_8TeVUp ->SetLineColor(2); wz3lnu_CMS_hzz2l2v_umetUp ->SetLineColor(2); wz3lnu_CMS_res_jUp ->SetLineColor(2); wz3lnu_CMS_scale_jUp ->SetLineColor(2); zll_CMS_hzz2l2v_stat_ll_zll_8TeVUp ->SetLineColor(2); topwwwjetsdata_CMS_hzz2l2v_stat_ll_topwwwjetsdata_8TeVUp ->SetLineColor(2); zz2l2nu_CMS_eff_bDown ->SetLineColor(3); zz2l2nu_CMS_hzz2l2v_QCD_ACC_JVetoDown ->SetLineColor(3); zz2l2nu_CMS_hzz2l2v_lesDown ->SetLineColor(3); zz2l2nu_CMS_hzz2l2v_puDown ->SetLineColor(3); zz2l2nu_CMS_hzz2l2v_stat_ll_zz2l2nu_8TeVDown ->SetLineColor(3); zz2l2nu_CMS_hzz2l2v_umetDown ->SetLineColor(3); zz2l2nu_CMS_res_jDown ->SetLineColor(3); zz2l2nu_CMS_scale_jDown ->SetLineColor(3); zz2l2nu_CMS_hzz2l2v_sherpaDown ->SetLineColor(3); wz3lnu_CMS_eff_bDown ->SetLineColor(3); wz3lnu_CMS_hzz2l2v_lesDown ->SetLineColor(3); wz3lnu_CMS_hzz2l2v_puDown ->SetLineColor(3); wz3lnu_CMS_hzz2l2v_stat_ll_wz3lnu_8TeVDown ->SetLineColor(3); wz3lnu_CMS_hzz2l2v_umetDown ->SetLineColor(3); wz3lnu_CMS_res_jDown ->SetLineColor(3); wz3lnu_CMS_scale_jDown ->SetLineColor(3); zll_CMS_hzz2l2v_stat_ll_zll_8TeVDown ->SetLineColor(3); topwwwjetsdata_CMS_hzz2l2v_stat_ll_topwwwjetsdata_8TeVDown ->SetLineColor(3); TCanvas * c1_eff_b=new TCanvas("c1_eff_b","c1_eff_b",600,600); zz2l2nu_CMS_eff_bUp->Draw("histo"); zz2l2nu_CMS_eff_bDown->Draw("samehisto"); zz2l2nu->Draw("histosame"); TCanvas * c1_hzz2l2v_QCD_ACC_JVeto=new TCanvas("c1_hzz2l2v_QCD_ACC_JVeto","c1_hzz2l2v_QCD_ACC_JVeto",600,600); zz2l2nu_CMS_hzz2l2v_QCD_ACC_JVetoUp->Draw("histo"); zz2l2nu_CMS_hzz2l2v_QCD_ACC_JVetoDown->Draw("samehisto"); zz2l2nu->Draw("histosame"); TCanvas * c1_hzz2l2v_les=new TCanvas("c1_hzz2l2v_les","c1_hzz2l2v_les",600,600); zz2l2nu_CMS_hzz2l2v_lesUp->Draw("histo"); zz2l2nu_CMS_hzz2l2v_lesDown->Draw("samehisto"); zz2l2nu->Draw("histosame"); TCanvas * c1_hzz2l2v_pu=new TCanvas("c1_hzz2l2v_pu","c1_hzz2l2v_pu",600,600); zz2l2nu_CMS_hzz2l2v_puUp->Draw("histo"); zz2l2nu_CMS_hzz2l2v_puDown->Draw("samehisto"); zz2l2nu->Draw("histosame"); TCanvas * c1_hzz2l2v_stat_ll_zz2l2nu_8TeV=new TCanvas("c1_hzz2l2v_stat_ll_zz2l2nu_8TeV","c1_hzz2l2v_stat_ll_zz2l2nu_8TeV",600,600); zz2l2nu_CMS_hzz2l2v_stat_ll_zz2l2nu_8TeVUp->Draw("histo"); zz2l2nu_CMS_hzz2l2v_stat_ll_zz2l2nu_8TeVDown->Draw("samehisto"); zz2l2nu->Draw("histosame"); TCanvas * c1_hzz2l2v_umet=new TCanvas("c1_hzz2l2v_umet","c1_hzz2l2v_umet",600,600); zz2l2nu_CMS_hzz2l2v_umetUp->Draw("histo"); zz2l2nu_CMS_hzz2l2v_umetDown->Draw("samehisto"); zz2l2nu->Draw("histosame"); TCanvas * c1_res_j=new TCanvas("c1_res_j","c1_res_j",600,600); zz2l2nu_CMS_res_jUp->Draw("histo"); zz2l2nu_CMS_res_jDown->Draw("samehisto"); zz2l2nu->Draw("histosame"); TCanvas * c1_scale_j=new TCanvas("c1_scale_j","c1_scale_j",600,600); zz2l2nu_CMS_scale_jDown->Draw("histo"); zz2l2nu_CMS_scale_jUp->Draw("samehisto"); // zz2l2nu_CMS_scale_jDown->Draw("samehisto"); zz2l2nu->Draw("histosame"); TCanvas * c1_hzz2l2v_sherpa=new TCanvas("c1_hzz2l2v_sherpa","c1_hzz2l2v_sherpa",600,600); zz2l2nu_CMS_hzz2l2v_sherpaUp->Draw("histo"); zz2l2nu_CMS_hzz2l2v_sherpaDown->Draw("samehisto"); zz2l2nu->Draw("histosame"); TCanvas * c1_wz3lnu_eff_b=new TCanvas("c1_wz3lnu_eff_b","c1_wz3lnu_eff_b",600,600); wz3lnu_CMS_eff_bUp->Draw("histo"); wz3lnu_CMS_eff_bDown->Draw("samehisto"); wz3lnu->Draw("histosame"); TCanvas * c1_wz3lnu_hzz2l2v_les=new TCanvas("c1_wz3lnu_hzz2l2v_les","c1_wz3lnu_hzz2l2v_les",600,600); wz3lnu_CMS_hzz2l2v_lesUp->Draw("histo"); wz3lnu_CMS_hzz2l2v_lesDown->Draw("samehisto"); wz3lnu->Draw("histosame"); TCanvas * c1_wz3lnu_hzz2l2v_pu=new TCanvas("c1_wz3lnu_hzz2l2v_pu","c1_wz3lnu_hzz2l2v_pu",600,600); wz3lnu_CMS_hzz2l2v_puUp->Draw("histo"); wz3lnu_CMS_hzz2l2v_puDown->Draw("samehisto"); wz3lnu->Draw("histosame"); TCanvas * c1_wz3lnu_hzz2l2v_stat_ll_wz3lnu_8TeV=new TCanvas("c1_wz3lnu_hzz2l2v_stat_ll_wz3lnu_8TeV","c1_wz3lnu_hzz2l2v_stat_ll_wz3lnu_8TeV",600,600); wz3lnu_CMS_hzz2l2v_stat_ll_wz3lnu_8TeVUp->Draw("histo"); wz3lnu_CMS_hzz2l2v_stat_ll_wz3lnu_8TeVDown->Draw("samehisto"); wz3lnu->Draw("histosame"); TCanvas * c1_wz3lnu_hzz2l2v_umet=new TCanvas("c1_wz3lnu_hzz2l2v_umet","c1_wz3lnu_hzz2l2v_umet",600,600); wz3lnu_CMS_hzz2l2v_umetUp->Draw("histo"); wz3lnu_CMS_hzz2l2v_umetDown->Draw("samehisto"); wz3lnu->Draw("histosame"); TCanvas * c1_wz3lnu_res_j=new TCanvas("c1_wz3lnu_res_j","c1_wz3lnu_res_j",600,600); wz3lnu_CMS_res_jUp->Draw("histo"); wz3lnu_CMS_res_jDown->Draw("samehisto"); wz3lnu->Draw("histosame"); TCanvas * c1_wz3lnu_scale_j=new TCanvas("c1_wz3lnu_scale_j","c1_wz3lnu_scale_j",600,600); wz3lnu_CMS_scale_jDown->Draw("histo"); wz3lnu_CMS_scale_jUp->Draw("samehisto"); // wz3lnu_CMS_scale_jDown->Draw("samehisto"); wz3lnu->Draw("histosame"); TCanvas * c1_zll_hzz2l2v_stat_ll_zll_8TeV=new TCanvas("c1_zll_hzz2l2v_stat_ll_zll_8TeV","c1_zll_hzz2l2v_stat_ll_zll_8TeV",600,600); zll_CMS_hzz2l2v_stat_ll_zll_8TeVUp->Draw("histo"); zll_CMS_hzz2l2v_stat_ll_zll_8TeVDown->Draw("samehisto"); zll->Draw("histosame"); TCanvas * c1_top_hzz2l2v_stat_ll_topwwwjetsdata_8TeV=new TCanvas("c1_top_hzz2l2v_stat_ll_topwwwjetsdata_8TeV","c1_top_hzz2l2v_stat_ll_topwwwjetsdata_8TeV",600,600); topwwwjetsdata_CMS_hzz2l2v_stat_ll_topwwwjetsdata_8TeVUp->Draw("histo"); topwwwjetsdata_CMS_hzz2l2v_stat_ll_topwwwjetsdata_8TeVDown->Draw("samehisto"); topwwwjetsdata->Draw("histosame"); }

senka.duric@cern.ch

14ebb3be62e42e60047eccb260e7219aef395c97

fd90d577d6c848607ef56bf24ce5fe108bf13da8

/devices/MIMXRT1062/drivers/fsl_elcdif.h

063a1b777f2ac43caacb0d986b90537a498ea099

permissive

JayHeng/imxrt-tool-flash-algo

210e7adb904c8d95761e2914e69b8cc15e349326

0af70dfeea9dea669916bf404769144ed403a5e1

refs/heads/master

Apache-2.0

C

UTF-8

C

h

/* * Copyright 2017-2019 NXP * All rights reserved. * * * SPDX-License-Identifier: BSD-3-Clause */ #ifndef _FSL_ELCDIF_H_ #define _FSL_ELCDIF_H_ #include "fsl_common.h" /*! * @addtogroup elcdif * @{ */ /******************************************************************************* * Definitions ******************************************************************************/ /*! @name Driver version */ /*@{*/ /*! @brief eLCDIF driver version */ #define FSL_ELCDIF_DRIVER_VERSION (MAKE_VERSION(2, 0, 2)) /*@}*/ /* All IRQ flags in CTRL1 register. */ #define ELCDIF_CTRL1_IRQ_MASK \ (LCDIF_CTRL1_BM_ERROR_IRQ_MASK | LCDIF_CTRL1_OVERFLOW_IRQ_MASK | LCDIF_CTRL1_UNDERFLOW_IRQ_MASK | \ LCDIF_CTRL1_CUR_FRAME_DONE_IRQ_MASK | LCDIF_CTRL1_VSYNC_EDGE_IRQ_MASK) /* All IRQ enable control bits in CTRL1 register. */ #define ELCDIF_CTRL1_IRQ_EN_MASK \ (LCDIF_CTRL1_BM_ERROR_IRQ_EN_MASK | LCDIF_CTRL1_OVERFLOW_IRQ_EN_MASK | LCDIF_CTRL1_UNDERFLOW_IRQ_EN_MASK | \ LCDIF_CTRL1_CUR_FRAME_DONE_IRQ_EN_MASK | LCDIF_CTRL1_VSYNC_EDGE_IRQ_EN_MASK) /* All IRQ flags in AS_CTRL register. */ #if defined(LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_MASK) #define ELCDIF_AS_CTRL_IRQ_MASK (LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_MASK) #else #define ELCDIF_AS_CTRL_IRQ_MASK 0U #endif /* All IRQ enable control bits in AS_CTRL register. */ #if defined(LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_EN_MASK) #define ELCDIF_AS_CTRL_IRQ_EN_MASK (LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_EN_MASK) #else #define ELCDIF_AS_CTRL_IRQ_EN_MASK 0U #endif #if ((ELCDIF_CTRL1_IRQ_MASK & ELCDIF_AS_CTRL_IRQ_MASK) || (ELCDIF_AS_CTRL_IRQ_MASK & ELCDIF_AS_CTRL_IRQ_EN_MASK)) #error Interrupt bits overlap, need to update the interrupt functions. #endif /* LUT memory entery number. */ #define ELCDIF_LUT_ENTRY_NUM 256U /*! * @brief eLCDIF signal polarity flags */ enum _elcdif_polarity_flags { kELCDIF_VsyncActiveLow = 0U, /*!< VSYNC active low. */ kELCDIF_VsyncActiveHigh = LCDIF_VDCTRL0_VSYNC_POL_MASK, /*!< VSYNC active high. */ kELCDIF_HsyncActiveLow = 0U, /*!< HSYNC active low. */ kELCDIF_HsyncActiveHigh = LCDIF_VDCTRL0_HSYNC_POL_MASK, /*!< HSYNC active high. */ kELCDIF_DataEnableActiveLow = 0U, /*!< Data enable line active low. */ kELCDIF_DataEnableActiveHigh = LCDIF_VDCTRL0_ENABLE_POL_MASK, /*!< Data enable line active high. */ kELCDIF_DriveDataOnFallingClkEdge = 0U, /*!< Drive data on falling clock edge, capture data on rising clock edge. */ kELCDIF_DriveDataOnRisingClkEdge = LCDIF_VDCTRL0_DOTCLK_POL_MASK, /*!< Drive data on falling clock edge, capture data on rising clock edge. */ }; /*! * @brief The eLCDIF interrupts to enable. */ enum _elcdif_interrupt_enable { kELCDIF_BusMasterErrorInterruptEnable = LCDIF_CTRL1_BM_ERROR_IRQ_EN_MASK, /*!< Bus master error interrupt. */ kELCDIF_TxFifoOverflowInterruptEnable = LCDIF_CTRL1_OVERFLOW_IRQ_EN_MASK, /*!< TXFIFO overflow interrupt. */ kELCDIF_TxFifoUnderflowInterruptEnable = LCDIF_CTRL1_UNDERFLOW_IRQ_EN_MASK, /*!< TXFIFO underflow interrupt. */ kELCDIF_CurFrameDoneInterruptEnable = LCDIF_CTRL1_CUR_FRAME_DONE_IRQ_EN_MASK, /*!< Interrupt when hardware enters vertical blanking state. */ kELCDIF_VsyncEdgeInterruptEnable = LCDIF_CTRL1_VSYNC_EDGE_IRQ_EN_MASK, /*!< Interrupt when hardware encounters VSYNC edge. */ #if defined(LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_EN_MASK) kELCDIF_SciSyncOnInterruptEnable = LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_EN_MASK, /*!< Interrupt when eLCDIF lock with CSI input. */ #endif }; /*! * @brief The eLCDIF interrupt status flags. */ enum _elcdif_interrupt_flags { kELCDIF_BusMasterError = LCDIF_CTRL1_BM_ERROR_IRQ_MASK, /*!< Bus master error interrupt. */ kELCDIF_TxFifoOverflow = LCDIF_CTRL1_OVERFLOW_IRQ_MASK, /*!< TXFIFO overflow interrupt. */ kELCDIF_TxFifoUnderflow = LCDIF_CTRL1_UNDERFLOW_IRQ_MASK, /*!< TXFIFO underflow interrupt. */ kELCDIF_CurFrameDone = LCDIF_CTRL1_CUR_FRAME_DONE_IRQ_MASK, /*!< Interrupt when hardware enters vertical blanking state. */ kELCDIF_VsyncEdge = LCDIF_CTRL1_VSYNC_EDGE_IRQ_MASK, /*!< Interrupt when hardware encounters VSYNC edge. */ #if defined(LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_MASK) kELCDIF_SciSyncOn = LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_MASK, /*!< Interrupt when eLCDIF lock with CSI input. */ #endif }; /*! * @brief eLCDIF status flags */ enum _elcdif_status_flags { kELCDIF_LFifoFull = LCDIF_STAT_LFIFO_FULL_MASK, /*!< LFIFO full. */ kELCDIF_LFifoEmpty = LCDIF_STAT_LFIFO_EMPTY_MASK, /*!< LFIFO empty. */ kELCDIF_TxFifoFull = LCDIF_STAT_TXFIFO_FULL_MASK, /*!< TXFIFO full. */ kELCDIF_TxFifoEmpty = LCDIF_STAT_TXFIFO_EMPTY_MASK, /*!< TXFIFO empty. */ #if defined(LCDIF_STAT_BUSY_MASK) kELCDIF_LcdControllerBusy = LCDIF_STAT_BUSY_MASK, /*!< The external LCD controller busy signal. */ #endif #if defined(LCDIF_STAT_DVI_CURRENT_FIELD_MASK) kELCDIF_CurDviField2 = LCDIF_STAT_DVI_CURRENT_FIELD_MASK, /*!< Current DVI filed, if set, then current filed is 2, otherwise current filed is 1. */ #endif }; /*! * @brief The pixel format. * * This enumerator should be defined together with the array s_pixelFormatReg. * To support new pixel format, enhance this enumerator and s_pixelFormatReg. */ typedef enum _elcdif_pixel_format { kELCDIF_PixelFormatRAW8 = 0, /*!< RAW 8 bit, four data use 32 bits. */ kELCDIF_PixelFormatRGB565 = 1, /*!< RGB565, two pixel use 32 bits. */ kELCDIF_PixelFormatRGB666 = 2, /*!< RGB666 unpacked, one pixel uses 32 bits, high byte unused, upper 2 bits of other bytes unused. */ kELCDIF_PixelFormatXRGB8888 = 3, /*!< XRGB8888 unpacked, one pixel uses 32 bits, high byte unused. */ kELCDIF_PixelFormatRGB888 = 4, /*!< RGB888 packed, one pixel uses 24 bits. */ } elcdif_pixel_format_t; /*! @brief The LCD data bus type. */ typedef enum _elcdif_lcd_data_bus { kELCDIF_DataBus8Bit = LCDIF_CTRL_LCD_DATABUS_WIDTH(1), /*!< 8-bit data bus. */ kELCDIF_DataBus16Bit = LCDIF_CTRL_LCD_DATABUS_WIDTH(0), /*!< 16-bit data bus, support RGB565. */ kELCDIF_DataBus18Bit = LCDIF_CTRL_LCD_DATABUS_WIDTH(2), /*!< 18-bit data bus, support RGB666. */ kELCDIF_DataBus24Bit = LCDIF_CTRL_LCD_DATABUS_WIDTH(3), /*!< 24-bit data bus, support RGB888. */ } elcdif_lcd_data_bus_t; /*! * @brief The register value when using different pixel format. * * These register bits control the pixel format: * - CTRL[DATA_FORMAT_24_BIT] * - CTRL[DATA_FORMAT_18_BIT] * - CTRL[DATA_FORMAT_16_BIT] * - CTRL[WORD_LENGTH] * - CTRL1[BYTE_PACKING_FORMAT] */ typedef struct _elcdif_pixel_format_reg { uint32_t regCtrl; /*!< Value of register CTRL. */ uint32_t regCtrl1; /*!< Value of register CTRL1. */ } elcdif_pixel_format_reg_t; /*! * @brief eLCDIF configure structure for RGB mode (DOTCLK mode). */ typedef struct _elcdif_rgb_mode_config { uint16_t panelWidth; /*!< Display panel width, pixels per line. */ uint16_t panelHeight; /*!< Display panel height, how many lines per panel. */ uint8_t hsw; /*!< HSYNC pulse width. */ uint8_t hfp; /*!< Horizontal front porch. */ uint8_t hbp; /*!< Horizontal back porch. */ uint8_t vsw; /*!< VSYNC pulse width. */ uint8_t vfp; /*!< Vrtical front porch. */ uint8_t vbp; /*!< Vertical back porch. */ uint32_t polarityFlags; /*!< OR'ed value of @ref _elcdif_polarity_flags, used to contol the signal polarity. */ uint32_t bufferAddr; /*!< Frame buffer address. */ elcdif_pixel_format_t pixelFormat; /*!< Pixel format. */ elcdif_lcd_data_bus_t dataBus; /*!< LCD data bus. */ } elcdif_rgb_mode_config_t; /*! * @brief eLCDIF alpha surface pixel format. */ typedef enum _elcdif_as_pixel_format { kELCDIF_AsPixelFormatARGB8888 = 0x0, /*!< 32-bit pixels with alpha. */ kELCDIF_AsPixelFormatRGB888 = 0x4, /*!< 32-bit pixels without alpha (unpacked 24-bit format) */ kELCDIF_AsPixelFormatARGB1555 = 0x8, /*!< 16-bit pixels with alpha. */ kELCDIF_AsPixelFormatARGB4444 = 0x9, /*!< 16-bit pixels with alpha. */ kELCDIF_AsPixelFormatRGB555 = 0xC, /*!< 16-bit pixels without alpha. */ kELCDIF_AsPixelFormatRGB444 = 0xD, /*!< 16-bit pixels without alpha. */ kELCDIF_AsPixelFormatRGB565 = 0xE, /*!< 16-bit pixels without alpha. */ } elcdif_as_pixel_format_t; /*! * @brief eLCDIF alpha surface buffer configuration. */ typedef struct _elcdif_as_buffer_config { uint32_t bufferAddr; /*!< Buffer address. */ elcdif_as_pixel_format_t pixelFormat; /*!< Pixel format. */ } elcdif_as_buffer_config_t; /*! * @brief eLCDIF alpha mode during blending. */ typedef enum _elcdif_alpha_mode { kELCDIF_AlphaEmbedded, /*!< The alpha surface pixel alpha value will be used for blend. */ kELCDIF_AlphaOverride, /*!< The user defined alpha value will be used for blend directly. */ kELCDIF_AlphaMultiply, /*!< The alpha surface pixel alpha value scaled the user defined alpha value will be used for blend, for example, pixel alpha set set to 200, user defined alpha set to 100, then the reault alpha is 200 * 100 / 255. */ kELCDIF_AlphaRop /*!< Raster operation. */ } elcdif_alpha_mode_t; /*! * @brief eLCDIF ROP mode during blending. * * Explanation: * - AS: Alpha surface * - PS: Process surface * - nAS: Alpha surface NOT value * - nPS: Process surface NOT value */ typedef enum _elcdif_rop_mode { kELCDIF_RopMaskAs = 0x0, /*!< AS AND PS. */ kELCDIF_RopMaskNotAs = 0x1, /*!< nAS AND PS. */ kELCDIF_RopMaskAsNot = 0x2, /*!< AS AND nPS. */ kELCDIF_RopMergeAs = 0x3, /*!< AS OR PS. */ kELCDIF_RopMergeNotAs = 0x4, /*!< nAS OR PS. */ kELCDIF_RopMergeAsNot = 0x5, /*!< AS OR nPS. */ kELCDIF_RopNotCopyAs = 0x6, /*!< nAS. */ kELCDIF_RopNot = 0x7, /*!< nPS. */ kELCDIF_RopNotMaskAs = 0x8, /*!< AS NAND PS. */ kELCDIF_RopNotMergeAs = 0x9, /*!< AS NOR PS. */ kELCDIF_RopXorAs = 0xA, /*!< AS XOR PS. */ kELCDIF_RopNotXorAs = 0xB /*!< AS XNOR PS. */ } elcdif_rop_mode_t; /*! * @brief eLCDIF alpha surface blending configuration. */ typedef struct _elcdif_as_blend_config { uint8_t alpha; /*!< User defined alpha value, only used when @ref alphaMode is @ref kELCDIF_AlphaOverride or @ref kELCDIF_AlphaRop. */ bool invertAlpha; /*!< Set true to invert the alpha. */ elcdif_alpha_mode_t alphaMode; /*!< Alpha mode. */ elcdif_rop_mode_t ropMode; /*!< ROP mode, only valid when @ref alphaMode is @ref kELCDIF_AlphaRop. */ } elcdif_as_blend_config_t; /*! * @brief eLCDIF LUT * * The Lookup Table (LUT) is used to expand the 8 bits pixel to 24 bits pixel * before output to external displayer. * * There are two 256x24 bits LUT memory in LCDIF, the LSB of frame buffer address * determins which memory to use. */ typedef enum _elcdif_lut { kELCDIF_Lut0 = 0, /*!< LUT 0. */ kELCDIF_Lut1, /*!< LUT 1. */ } elcdif_lut_t; /******************************************************************************* * APIs ******************************************************************************/ #if defined(__cplusplus) extern "C" { #endif /* __cplusplus */ /*! * @name eLCDIF initialization and de-initialization * @{ */ /*! * @brief Initializes the eLCDIF to work in RGB mode (DOTCLK mode). * * This function ungates the eLCDIF clock and configures the eLCDIF peripheral according * to the configuration structure. * * @param base eLCDIF peripheral base address. * @param config Pointer to the configuration structure. */ void ELCDIF_RgbModeInit(LCDIF_Type *base, const elcdif_rgb_mode_config_t *config); /*! * @brief Gets the eLCDIF default configuration structure for RGB (DOTCLK) mode. * * This function sets the configuration structure to default values. * The default configuration is set to the following values. * @code config->panelWidth = 480U; config->panelHeight = 272U; config->hsw = 41; config->hfp = 4; config->hbp = 8; config->vsw = 10; config->vfp = 4; config->vbp = 2; config->polarityFlags = kELCDIF_VsyncActiveLow | kELCDIF_HsyncActiveLow | kELCDIF_DataEnableActiveLow | kELCDIF_DriveDataOnFallingClkEdge; config->bufferAddr = 0U; config->pixelFormat = kELCDIF_PixelFormatRGB888; config->dataBus = kELCDIF_DataBus24Bit; @code * * @param config Pointer to the eLCDIF configuration structure. */ void ELCDIF_RgbModeGetDefaultConfig(elcdif_rgb_mode_config_t *config); /*! * @brief Deinitializes the eLCDIF peripheral. * * @param base eLCDIF peripheral base address. */ void ELCDIF_Deinit(LCDIF_Type *base); /* @} */ /*! * @name Module operation * @{ */ /*! * @brief Set the pixel format in RGB (DOTCLK) mode. * * @param base eLCDIF peripheral base address. * @param pixelFormat The pixel format. */ void ELCDIF_RgbModeSetPixelFormat(LCDIF_Type *base, elcdif_pixel_format_t pixelFormat); /*! * @brief Start to display in RGB (DOTCLK) mode. * * @param base eLCDIF peripheral base address. */ static inline void ELCDIF_RgbModeStart(LCDIF_Type *base) { base->CTRL_SET = LCDIF_CTRL_RUN_MASK | LCDIF_CTRL_DOTCLK_MODE_MASK; } /*! * @brief Stop display in RGB (DOTCLK) mode and wait until finished. * * @param base eLCDIF peripheral base address. */ void ELCDIF_RgbModeStop(LCDIF_Type *base); /*! * @brief Set the next frame buffer address to display. * * @param base eLCDIF peripheral base address. * @param bufferAddr The frame buffer address to set. */ static inline void ELCDIF_SetNextBufferAddr(LCDIF_Type *base, uint32_t bufferAddr) { base->NEXT_BUF = bufferAddr; } /*! * @brief Reset the eLCDIF peripheral. * * @param base eLCDIF peripheral base address. */ void ELCDIF_Reset(LCDIF_Type *base); #if !(defined(FSL_FEATURE_LCDIF_HAS_NO_RESET_PIN) && FSL_FEATURE_LCDIF_HAS_NO_RESET_PIN) /*! * @brief Pull up or down the reset pin for the externel LCD controller. * * @param base eLCDIF peripheral base address. * @param pullUp True to pull up reset pin, false to pull down. */ static inline void ELCDIF_PullUpResetPin(LCDIF_Type *base, bool pullUp) { if (pullUp) { base->CTRL1_SET = LCDIF_CTRL1_RESET_MASK; } else { base->CTRL1_CLR = LCDIF_CTRL1_RESET_MASK; } } #endif /*! * @brief Enable or disable the hand shake with PXP. * * @param base eLCDIF peripheral base address. * @param enable True to enable, false to disable. */ static inline void ELCDIF_EnablePxpHandShake(LCDIF_Type *base, bool enable) { if (enable) { base->CTRL_SET = LCDIF_CTRL_ENABLE_PXP_HANDSHAKE_MASK; } else { base->CTRL_CLR = LCDIF_CTRL_ENABLE_PXP_HANDSHAKE_MASK; } } /* @} */ /*! * @name Status * @{ */ /*! * @brief Get the CRC value of the frame sent out. * * When a frame is sent complete (the interrupt @ref kELCDIF_CurFrameDone assert), this function * can be used to get the CRC value of the frame sent. * * @param base eLCDIF peripheral base address. * @return The CRC value. * * @note The CRC value is dependent on the LCD_DATABUS_WIDTH. */ static inline uint32_t ELCDIF_GetCrcValue(LCDIF_Type *base) { return base->CRC_STAT; } /*! * @brief Get the bus master error virtual address. * * When bus master error occurs (the interrupt kELCDIF_BusMasterError assert), this function * can get the virtual address at which the AXI master received an error * response from the slave. * * @param base eLCDIF peripheral base address. * @return The error virtual address. */ static inline uint32_t ELCDIF_GetBusMasterErrorAddr(LCDIF_Type *base) { return base->BM_ERROR_STAT; } /*! * @brief Get the eLCDIF status. * * The status flags are returned as a mask value, application could check the * corresponding bit. Example: * * @code uint32_t statusFlags; statusFlags = ELCDIF_GetStatus(LCDIF); if (kELCDIF_LFifoFull & statusFlags) { } if (kELCDIF_TxFifoEmpty & statusFlags) { } @endcode * * @param base eLCDIF peripheral base address. * @return The mask value of status flags, it is OR'ed value of @ref _elcdif_status_flags. */ static inline uint32_t ELCDIF_GetStatus(LCDIF_Type *base) { return base->STAT & (LCDIF_STAT_LFIFO_FULL_MASK | LCDIF_STAT_LFIFO_EMPTY_MASK | LCDIF_STAT_TXFIFO_FULL_MASK | LCDIF_STAT_TXFIFO_EMPTY_MASK #if defined(LCDIF_STAT_BUSY_MASK) | LCDIF_STAT_BUSY_MASK #endif #if defined(LCDIF_STAT_DVI_CURRENT_FIELD_MASK) | LCDIF_STAT_DVI_CURRENT_FIELD_MASK #endif ); } /*! * @brief Get current count in Latency buffer (LFIFO). * * @param base eLCDIF peripheral base address. * @return The LFIFO current count */ static inline uint32_t ELCDIF_GetLFifoCount(LCDIF_Type *base) { return (base->STAT & LCDIF_STAT_LFIFO_COUNT_MASK) >> LCDIF_STAT_LFIFO_COUNT_SHIFT; } /* @} */ /*! * @name Interrupts * @{ */ /*! * @brief Enables eLCDIF interrupt requests. * * @param base eLCDIF peripheral base address. * @param mask interrupt source, OR'ed value of _elcdif_interrupt_enable. */ static inline void ELCDIF_EnableInterrupts(LCDIF_Type *base, uint32_t mask) { base->CTRL1_SET = (mask & ELCDIF_CTRL1_IRQ_EN_MASK); #if !(defined(FSL_FEATURE_LCDIF_HAS_NO_AS) && FSL_FEATURE_LCDIF_HAS_NO_AS) base->AS_CTRL |= (mask & ELCDIF_AS_CTRL_IRQ_EN_MASK); #endif } /*! * @brief Disables eLCDIF interrupt requests. * * @param base eLCDIF peripheral base address. * @param mask interrupt source, OR'ed value of _elcdif_interrupt_enable. */ static inline void ELCDIF_DisableInterrupts(LCDIF_Type *base, uint32_t mask) { base->CTRL1_CLR = (mask & ELCDIF_CTRL1_IRQ_EN_MASK); #if !(defined(FSL_FEATURE_LCDIF_HAS_NO_AS) && FSL_FEATURE_LCDIF_HAS_NO_AS) base->AS_CTRL &= ~(mask & ELCDIF_AS_CTRL_IRQ_EN_MASK); #endif } /*! * @brief Get eLCDIF interrupt peding status. * * @param base eLCDIF peripheral base address. * @return Interrupt pending status, OR'ed value of _elcdif_interrupt_flags. */ static inline uint32_t ELCDIF_GetInterruptStatus(LCDIF_Type *base) { uint32_t flags; flags = (base->CTRL1 & ELCDIF_CTRL1_IRQ_MASK); #if !(defined(FSL_FEATURE_LCDIF_HAS_NO_AS) && FSL_FEATURE_LCDIF_HAS_NO_AS) flags |= (base->AS_CTRL & ELCDIF_AS_CTRL_IRQ_MASK); #endif return flags; } /*! * @brief Clear eLCDIF interrupt peding status. * * @param base eLCDIF peripheral base address. * @param mask of the flags to clear, OR'ed value of _elcdif_interrupt_flags. */ static inline void ELCDIF_ClearInterruptStatus(LCDIF_Type *base, uint32_t mask) { base->CTRL1_CLR = (mask & ELCDIF_CTRL1_IRQ_MASK); #if !(defined(FSL_FEATURE_LCDIF_HAS_NO_AS) && FSL_FEATURE_LCDIF_HAS_NO_AS) base->AS_CTRL &= ~(mask & ELCDIF_AS_CTRL_IRQ_MASK); #endif } /* @} */ #if !(defined(FSL_FEATURE_LCDIF_HAS_NO_AS) && FSL_FEATURE_LCDIF_HAS_NO_AS) /*! * @name Alpha surface * @{ */ /*! * @brief Set the configuration for alpha surface buffer. * * @param base eLCDIF peripheral base address. * @param config Pointer to the configuration structure. */ void ELCDIF_SetAlphaSurfaceBufferConfig(LCDIF_Type *base, const elcdif_as_buffer_config_t *config); /*! * @brief Set the alpha surface blending configuration. * * @param base eLCDIF peripheral base address. * @param config Pointer to the configuration structure. */ void ELCDIF_SetAlphaSurfaceBlendConfig(LCDIF_Type *base, const elcdif_as_blend_config_t *config); /*! * @brief Set the next alpha surface buffer address. * * @param base eLCDIF peripheral base address. * @param bufferAddr Alpha surface buffer address. */ static inline void ELCDIF_SetNextAlphaSurfaceBufferAddr(LCDIF_Type *base, uint32_t bufferAddr) { base->AS_NEXT_BUF = bufferAddr; } /*! * @brief Set the overlay color key. * * If a pixel in the current overlay image with a color that falls in the range * from the @p colorKeyLow to @p colorKeyHigh range, it will use the process surface * pixel value for that location. * * @param base eLCDIF peripheral base address. * @param colorKeyLow Color key low range. * @param colorKeyHigh Color key high range. * * @note Colorkey operations are higher priority than alpha or ROP operations */ static inline void ELCDIF_SetOverlayColorKey(LCDIF_Type *base, uint32_t colorKeyLow, uint32_t colorKeyHigh) { base->AS_CLRKEYLOW = colorKeyLow; base->AS_CLRKEYHIGH = colorKeyHigh; } /*! * @brief Enable or disable the color key. * * @param base eLCDIF peripheral base address. * @param enable True to enable, false to disable. */ static inline void ELCDIF_EnableOverlayColorKey(LCDIF_Type *base, bool enable) { if (enable) { base->AS_CTRL |= LCDIF_AS_CTRL_ENABLE_COLORKEY_MASK; } else { base->AS_CTRL &= ~LCDIF_AS_CTRL_ENABLE_COLORKEY_MASK; } } /*! * @brief Enable or disable the alpha surface. * * @param base eLCDIF peripheral base address. * @param enable True to enable, false to disable. */ static inline void ELCDIF_EnableAlphaSurface(LCDIF_Type *base, bool enable) { if (enable) { base->AS_CTRL |= LCDIF_AS_CTRL_AS_ENABLE_MASK; } else { base->AS_CTRL &= ~LCDIF_AS_CTRL_AS_ENABLE_MASK; } } /*! * @brief Enable or disable the process surface. * * Process surface is the normal frame buffer. The process surface content * is controlled by @ref ELCDIF_SetNextBufferAddr. * * @param base eLCDIF peripheral base address. * @param enable True to enable, false to disable. */ static inline void ELCDIF_EnableProcessSurface(LCDIF_Type *base, bool enable) { if (enable) { base->AS_CTRL &= ~LCDIF_AS_CTRL_PS_DISABLE_MASK; } else { base->AS_CTRL |= LCDIF_AS_CTRL_PS_DISABLE_MASK; } } /* @} */ #endif /* FSL_FEATURE_LCDIF_HAS_NO_AS */ #if (defined(FSL_FEATURE_LCDIF_HAS_LUT) && FSL_FEATURE_LCDIF_HAS_LUT) /*! * @name LUT * * The Lookup Table (LUT) is used to expand the 8 bits pixel to 24 bits pixel * before output to external displayer. * * There are two 256x24 bits LUT memory in LCDIF, the LSB of frame buffer address * determins which memory to use. * * @{ */ /*! * @brief Enable or disable the LUT. * * @param base eLCDIF peripheral base address. * @param enable True to enable, false to disable. */ static inline void ELCDIF_EnableLut(LCDIF_Type *base, bool enable) { if (enable) { base->LUT_CTRL &= ~LCDIF_LUT_CTRL_LUT_BYPASS_MASK; } else { base->LUT_CTRL |= LCDIF_LUT_CTRL_LUT_BYPASS_MASK; } } /*! * @brief Load the LUT value. * * This function loads the LUT value to the specific LUT memory, user can * specify the start entry index. * * @param base eLCDIF peripheral base address. * @param lut Which LUT to load. * @param startIndex The start index of the LUT entry to update. * @param lutData The LUT data to load. * @param count Count of @p lutData. * @retval kStatus_Success Initialization success. * @retval kStatus_InvalidArgument Wrong argument. */ status_t ELCDIF_UpdateLut( LCDIF_Type *base, elcdif_lut_t lut, uint16_t startIndex, const uint32_t *lutData, uint16_t count); /* @} */ #endif /* FSL_FEATURE_LCDIF_HAS_LUT */ #if defined(__cplusplus) } #endif /* __cplusplus */ /* @} */ #endif /*_FSL_ELCDIF_H_*/

jie.heng@nxp.com

9e778b020a7b122b424fc4a64f489a0fd59c25c5

77cf4be91eb945cacf96e8cc56bec03c97e144d0

/evenint.c

232a3918e7243568191620bd566d7bed14f716e8

no_license

THARANYATHANGAVEL/hai-dear

a3aa72c8b36315206321ff98f04ebbedde5fed79

3642319093c3da442c86e016b5c39d7fb4e71274

refs/heads/master

UTF-8

C

c

#include<stdio.h> #include<conio.h> void main() { int f,l,i; printf("enter the value first number"); scanf("%d",&f); printf("enter last value"); scanf("%d",&l); for(i=f;i<=l;i++) { if(i%2==0) { printf("%d",i); } } getch(); }

noreply@github.com

5db7b7772830f1476bd1d8df4109aad3f0f5a622

863f370574674bfcdc79961a4b1589778d6c2624

/charData.c

aa2272ccfbfdd60b293bca18134168435a8e11ae

no_license

NoMan2000/c-prog

df94aec681a41567093f1b24bbdae5359516cea7

6e20d0d98e772d0f37f32078ff6aecdbb1c8b4d2

refs/heads/master