Datasets:

Reset23

/

the-stack-v2-blamed-c

like 0

6e142e946a8eea810bceb15f7ada544ab9931cb0

6ef6213d2fa39d1d0ab7e2373d882b9d263e8c6d

/ti_components/algorithms/vlib_c66x_3_3_2_0/packages/ti/vlib/src/VLIB_ORB_computeOrientation/VLIB_ORB_computeOrientation_cn.h

b894dbc58a0b2a4caf5af6d8c2a4c550a38628ff

no_license

Zhangh2018/PROCESSOR_SDK_VISION_03_06_00_00

9c380d3167b156a11a8f21814e94ac5550cddc87

05c72de5d031006c7565d4234abd53670a926acd

refs/heads/master

UTF-8

C

h

/******************************************************************************* **+--------------------------------------------------------------------------+** **| **** |** **| **** |** **| ******o*** |** **| ********_///_**** |** **| ***** /_//_/ **** |** **| ** ** (__/ **** |** **| ********* |** **| **** |** **| *** |** **| |** **| Copyright (c) 2007-2012 Texas Instruments Incorporated |** **| ALL RIGHTS RESERVED |** **| |** **| Permission to use, copy, modify, or distribute this software, |** **| whether in part or in whole, for any purpose is forbidden without |** **| a signed licensing agreement and NDA from Texas Instruments |** **| Incorporated (TI). |** **| |** **| TI makes no representation or warranties with respect to the |** **| performance of this computer program, and specifically disclaims |** **| any responsibility for any damages, special or consequential, |** **| connected with the use of this program. |** **| |** **+--------------------------------------------------------------------------+** *******************************************************************************/ #ifndef VLIB_ORB_COMPUTEORIENTATION_CN_H_ #define VLIB_ORB_COMPUTEORIENTATION_CN_H_ 1 #include "../common/VLIB_types.h" #include "../common/VLIB_orb.h" CORBResult VLIB_ORB_computeOrientation_cn(uint8_t *inImg, uint16_t imgWidth, uint16_t imgHeight, uint16_t imgPitch, uint32_t *featuresLoc, uint16_t numFeatures, int16_t *outAngle, uint8_t *momentPattern, uint8_t *scratch); #endif /* ======================================================================== */ /* End of file: VLIB_ORB_computeOrientation_cn.h */ /* ======================================================================== */

yukichen@otobrite.com

87b393e0e37d196a9779122a7240425d0269f0da

3c406f63a82affe48a40c6e4312ad071aebcf62e

/static/test.c

d6839978199fc1bb3d5e211d972bd5e850265b0f

no_license

vivek703/OWN_EXP

d1a2c78ea69a7114088783e373660d2d39ed317e

fe0f7359693d8822b52121e07d808495f1c93e5e

refs/heads/master

UTF-8

C

c

#include "test.h" #include <stdio.h> static int static_1(void) { printf("HI\n"); } void test(void) { static_1(); }

vivekp9922@gmail.com

cf438c03fe427b18d5ef0c3ee6b083cbcaf7fb89

2837f8a4e1c618f00ad7ba5cf4c248232ea1743b

/1012.c

13ca81f31503b51ffd86f58d4a77bd3cf3a1fc50

no_license

jorgeduartejr/URI-online-judge---C

c56a2e887db097725694bef25ac390e9edb38b26

d913288c68870f1058bd7fb0ce754ebc3a015ef8

refs/heads/main

UTF-8

C

c

#include <stdio.h> int main() { double A,B,C; double areaTriangulo, areaCirculo, areaTrapezio, areaQuadrado, areaRetangulo; double pi = 3.14159; scanf("%lf""%lf""%lf", &A,&B,&C); areaTriangulo = (A * C)/2; areaCirculo = C * C * pi; areaTrapezio = ((A + B) * C)/2; areaQuadrado = B * B; areaRetangulo = A * B; printf("TRIANGULO: %.3lf\n", areaTriangulo); printf("CIRCULO: %.3lf\n",areaCirculo); printf("TRAPEZIO: %.3lf\n",areaTrapezio); printf("QUADRADO: %.3lf\n", areaQuadrado); printf("RETANGULO: %.3lf\n", areaRetangulo); return 0; }

migueljunior1000@gmail.com

6e4b62fc82e9d7f43ce043d45c270328142a1c71

dec6419e67295954f5c526d9631685d9d8499342

/src/xoip_messages.c

7d8d11f458027296451ce911469b4db64fdc59bf

no_license

vassilux/xoip2

23029e19221f98fbb24368259ba0770541cdb8e2

4893d31a9dbad1fc585b515c3a371ce59f752180

refs/heads/master

UTF-8

C

c

/* * XoIP -- telephony toolkit. * * Copyright (C) <2014>, <vassilux> * * <Vassili Gontcharov> <v.gontcharov@gmail.com> * */ /*! \file * * \brief Xoipeton application * * \author\verbatim <Vassili Gontcharov> <vassili.gontcharov@esifrance.net> \endverbatim * * This is a Xoip for development of an Asterisk application * \ingroup applications */ /*** MODULEINFO <defaultenabled>no</defaultenabled> <support_level>core</support_level> ***/ #include <stdio.h> #include <stdlib.h> #include "asterisk.h" #include "asterisk/logger.h" //#include "asterisk/astmm.h" #include "xoip_messages.h" int do_process_message (const char *buf, int size, struct f1_messages_handlers *handlers); static void do_process_message_fa(int track, int callref, char *code, struct f1_messages_handlers *handlers) { if(code == NULL){ return; } if(code[0] == 'M'){ handlers->mute_micro_operator(track, callref, true); }else if(code[0] == 'N'){ handlers->mute_micro_operator(track, callref, false); } } /*! * \brief Intiaialize the emmessions configuration for the given communication. * * \param track The track number. * \param callref The call reference. * \param messages The string array of parameters. * \param handlers The pointer to the wrapper of the app_xoip functions. */ static void do_process_message_fc(int track, int callref, char messages[10][255], struct f1_messages_handlers *handlers) { char *emmission_type = messages[3]; int dtmf_duration = 0; int silence_duration = 0; int loudness = 0; if(emmission_type != NULL &&(strcmp(emmission_type, "DTMF") == 0)){ if(messages[4] != NULL){ /* * pay an attention cause the F1 send packege without , between DTMF * and duration */ dtmf_duration = atoi(messages[4] + 4); // move 4 to skip DTMF string } if(messages[5] != NULL){ silence_duration = atoi(messages[5]); } if(messages[6] != NULL){ loudness = atoi(messages[6]); } } } /*! * \brief Send the frequencies to th] channel identified by the given track and callref */ static void do_process_message_ff(int track, int callref, char messages[10][255], struct f1_messages_handlers *handlers) { int freq; int duration; int level; char *mode = NULL; char *break_record; if(messages[3] != NULL){ freq = atoi(messages[3]); } if(messages[4] != NULL){ duration = atoi(messages[4]); } if(messages[5] != NULL){ level = atoi(messages[5]); } mode = messages[6]; break_record = messages[6]; handlers->send_freq(track, callref, freq, duration, level, mode, break_record); } /*! * \brief Process FL message. Send data to the channel identificated by the given track and callref */ static void do_process_message_fl(int track, int callref, char messages[10][255], struct f1_messages_handlers *handlers) { int mode_transfer; char *data; char *mode_operator = NULL; char *break_record; if(messages[3] != NULL){ mode_transfer = atoi(messages[3]); } data = messages[4]; mode_operator = messages[5]; break_record = messages[6]; handlers->send_data(track, callref, mode_transfer, data, mode_operator, break_record); } /*! * */ int do_process_message (const char *buf, int size, struct f1_messages_handlers *handlers) { int res = 0; char *buffer = strdup (buf); const char *sep = ","; char messages[10][255] = { '\0' }; int count = 0; ast_verb(5, "Get packet from f1 endpoint : [%s\n]", buffer); char *token = NULL; for (token = strtok (buffer, sep); token; token = strtok (NULL, sep)) { if (token != NULL) { strcpy (messages[count], token); count++; } } char type = messages[0][2]; /* this is special case for ithe polling and mode request messages */ if(messages[0][0] == 'R' && type == 'S'){ handlers->request_reboot(); goto goout; }else if(type == 'N'){ /* skip this one */ handlers->request_mode_normal(); goto goout; }else if(messages[0][0]== 'V' && type == 'R'){ goto goout; }else if(type == 'P'){ ast_verb(5, "Get polling [%s].\n", messages[3]); handlers->polling(messages[3]); goto goout; } int track = atoi (messages[1]); long callref = 0; sscanf(messages[2], "%04X", &callref); /* so far sor good */ switch (type) { case 'A': do_process_message_fa(track, callref, messages[3], handlers); break; case 'C': do_process_message_fc(track, callref, messages, handlers); break; case 'F': do_process_message_ff(track, callref, messages, handlers); break; case 'G': { char proto = messages[3][0]; int level = 0; if (messages[4] != NULL) { level = atoi (messages[4]); } handlers->answer (track, callref, proto, level); } break; case 'H': { char *callee = messages[3]; char *caller = messages[4]; char *volum = messages[5]; handlers->commut (track, callref, callee, caller, volum); } break; case 'I': { char proto = messages[3][0]; int loudness = 0; if(messages[4] != NULL){ loudness = atoi(messages[4]); } handlers->switch_protocol(track, callref, proto, loudness); } break; case 'K': handlers->ack_alarm(track, callref); break; case 'L': do_process_message_fl(track, callref, messages, handlers); break; case 'M': { int record_track = 0; if(messages[3] != NULL){ record_track = atoi(messages[4]); } handlers->record_request(track, callref, record_track); } break; case 'r': case 'R': //ast_log(AST_LOG_VERBOSE, " Processing R.\n"); handlers->hangup (track, callref); break; case 'V': { int volume; if(messages[3] != NULL){ volume = atoi(messages[3]); } handlers->volume_adjust(track, callref, volume); } break; case 'W': handlers->queuing_call(track, callref, messages[3]); break; case 'U': break; default: ast_log (AST_LOG_VERBOSE, " Processing but type not found : [%c]..\n", buf); break; } goto goout; goout: res = size; free (buffer); return res; } /*! * */ int xoip_build_XC_msg (int voie, int callref, const char *did, const char *caller, const char *transfered, char *dest, int size) { snprintf (dest, size - 1, "X C,%02d,%04X,%s,%s,T%s\r", voie, callref, did, caller, transfered); if(strlen(dest) == 0){ return -1; } return 0; } /*! * */ int xoip_build_Xg_msg (int voie, int callref, int state, int res, char *dest, int size) { if(res != 0){ snprintf (dest, size - 1, "X g,%02d,%04X,1,%01d\r", voie, callref, res); }else{ snprintf (dest, size - 1, "X g,%02d,%04X,%d\r", voie, callref,state); } if(strlen(dest) == 0){ return -1; } return 0; } /*! * */ int xoip_build_XL_msg (int voie, int callref, int res, char *dest, int size) { if(res != 0){ snprintf (dest, size - 1, "X L,%02d,%04X,1,%01d\r", voie, callref, res); }else{ snprintf (dest, size - 1, "X L,%02d,%04d\r", voie, callref); } if(strlen(dest) == 0){ return -1; } return 0; } /*! * */ int xoip_build_Xm_msg(int voie, int callref, int state, int res, char *dest, int size) { if(res != 0){ snprintf (dest, size - 1, "X m,%02d,%04X,1,%01d\r", voie, callref, res); }else{ snprintf (dest, size - 1, "X m,%02d,%04d\r", voie, callref); } if(strlen(dest) == 0){ return -1; } return 0; } /*! * */ int xoip_build_XE_msg(int status, char *dest, int size) { snprintf (dest, size - 1, "X E,%01d,%s\r", status, "XoIP Alarms-V0.2.0.80,Dem V0000,Mod V0000"); if(strlen(dest) == 0){ return -1; } return 0; } /*! * */ int xoip_build_Xr_msg (int voie, int callref, char *dest, int size) { snprintf (dest, size, "X r,%02d,%04d\r", voie, callref); return 0; } /*! * */ int xoip_build_Xh_msg (int voie, int callref, int state, const char *callee, char *dest, int size) { snprintf (dest, size, "X h,%02d,%04X,%01d,%s\r", voie, callref, state, callee); return 0; } /*! * */ int xoip_build_Xi_msg(int voie, int callref, int state, int res, char *dest, int size) { snprintf (dest, size - 1, "X i,%02d,%04X,%01d,%01d\r", voie, callref, state, res); if(strlen(dest) == 0){ return -1; } return 0; } /*! * */ int xoip_build_Xk_msg(int voie, int callref, int state, int res, char *dest, int size) { snprintf (dest, size - 1, "X k,%02d,%04X,%01d,%01d\r", voie, callref, state, res); if(strlen(dest) == 0){ return -1; } return 0; } /*! * */ int xoip_build_Xf_msg (int voie, int callref, int state, int res, char *dest, int size) { snprintf (dest, size - 1, "X f,%02d,%04X,%01d,%01d\r", voie, callref, state, res); if(strlen(dest) == 0){ return -1; } return 0; } /*! * */ int xoip_build_XA_msg (int voie, int callref, const char *data, char *dest, int size) { snprintf (dest, size, "X A,%02d,%04X,%s\r", voie, callref, data); return 0; } /*! * \brief Build X w message. * The response for f1 F W request : qeueuing a call */ int xoip_build_Xw_msg(int voie, int callref, int res, char *dest, int size) { snprintf (dest, size - 1, "X w,%02d,%04X,%01d\r", voie, callref, res); if(strlen(dest) == 0){ return -1; } return 0; } /*! * \brief Parsing message from the given buffer. * Buffer can content few messges * * \param buf messages buffer * \param size the length of the buffer * \params handlers the structur of callback for each type of message * * \retval -1 on error * \retval > 0 the lenth of processing messages */ int process_message (const char *buf, int size, struct f1_messages_handlers *handlers) { int res = 0; int i = 0; int count = 0; char *buffer = strdup (buf); const char *sep = "\r"; char *token = NULL; /* must be changed */ char messages[10][255] = { '\0' }; for (token = strtok (buffer, sep); token; token = strtok (NULL, sep)) { strcpy (messages[count], token); count++; } res = 0; for (i = 0; i < count; i++) { /* increment by the token length */ res += do_process_message (messages[i], strlen (messages[i]), handlers); } /* add to the result the number of tokens. May be addt length(sep) can be good idea */ res += count; free (buffer); return res; }

v.gontcharov@gmail.com

37c89afb473fb1f0e71c3f743b0cc646712c4985

5c255f911786e984286b1f7a4e6091a68419d049

/vulnerable_code/0f76e37c-5ba9-431e-acb0-97747e28c6bb.c

d70ff0058833ce6c0df966372d79fbd154c48354

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=4; int j=13; int k; int l; k = 53; l = 64; k = i/j; l = i/j; l = j/j; l = l/j; l = l%j; l = l-j; k = k-k*i; //variables /* START VULNERABILITY */ int a; int b[28]; int c[67]; a = 0; while (a > -1) { //random /* START BUFFER SET */ *((int *)c + a) = *((int *)b + a); /* END BUFFER SET */ a--; } /* END VULNERABILITY */ printf("%d%d\n",k,l); return 0; }

nharmon8@gmail.com

435d938de995c245d164b32e935ec8b55a8bc340

bb762a49e4f5324de253d6287438899a4c645632

/Lista9/Questao1/tadArvoreBB3.c

9f8071a9ac77eb7d89a79a9acd91267be9385138

no_license

RaquelBelmiro/estruturas-de-dados-c

7de2defe4ffaf1849eb5408c533658c0637a1366

f38f6e6758a897a24e8091e773b6651f02e09a45

refs/heads/master

UTF-8

C

c

#include<stdio.h> #include<stdlib.h> struct reg_no_arvore { struct reg_no_arvore *ptrEsquerda; int chave; struct reg_no_arvore *ptrDireita; }; typedef struct reg_no_arvore **tipo_no_arvore; tipo_no_arvore inicializar_arvore(tipo_no_arvore sub_raiz) { sub_raiz = (struct reg_no_arvore**)malloc(sizeof(struct reg_no_arvore*)); *sub_raiz = NULL; } void incluir_no_arvore(tipo_no_arvore sub_raiz, int chave) { if (*sub_raiz == NULL) { *sub_raiz = malloc(sizeof(struct reg_no_arvore)); (*sub_raiz)->chave = chave; (*sub_raiz)->ptrEsquerda = NULL; (*sub_raiz)->ptrDireita = NULL; } else { if (chave < (*sub_raiz)->chave) { incluir_no_arvore(&((*sub_raiz)->ptrEsquerda), chave); } else { if (chave > (*sub_raiz)->chave) { incluir_no_arvore(&((*sub_raiz)->ptrDireita), chave); } } } } void percurso_em_ordem(tipo_no_arvore sub_raiz) { if (*sub_raiz != NULL) { percurso_em_ordem(&((*sub_raiz)->ptrEsquerda)); printf("%d ", (*sub_raiz)->chave); percurso_em_ordem(&((*sub_raiz)->ptrDireita)); } } void percurso_em_pre_ordem(tipo_no_arvore sub_raiz) { if (*sub_raiz != NULL) { printf("%d ", (*sub_raiz)->chave); percurso_em_pre_ordem(&((*sub_raiz)->ptrEsquerda)); percurso_em_pre_ordem(&((*sub_raiz)->ptrDireita)); } } void percurso_em_pos_ordem(tipo_no_arvore sub_raiz) { if (*sub_raiz != NULL) { percurso_em_pos_ordem(&((*sub_raiz)->ptrEsquerda)); percurso_em_pos_ordem(&((*sub_raiz)->ptrDireita)); printf("%d ", (*sub_raiz)->chave); } } int encontrar_elemento(tipo_no_arvore sub_raiz, int chave) { if ((*sub_raiz) == NULL) { return 0; } else { if (chave == (*sub_raiz)->chave) { return 1; } else { if (chave < (*sub_raiz)->chave) { return encontrar_elemento(&((*sub_raiz)->ptrEsquerda), chave); } else { if (chave > (*sub_raiz)->chave) { return encontrar_elemento(&((*sub_raiz)->ptrDireita), chave); } } } } } int numero_nos(tipo_no_arvore sub_raiz){ if (*sub_raiz != NULL) { return 1+numero_nos(&((*sub_raiz)->ptrEsquerda))+numero_nos(&((*sub_raiz)->ptrDireita)); } return 0; } int qtdFolha(tipo_no_arvore sub_raiz){ if (*sub_raiz !=NULL) { if(((*sub_raiz)->ptrEsquerda==NULL) && ((*sub_raiz)->ptrDireita==NULL)) return 1+qtdFolha(&(*sub_raiz)->ptrEsquerda) + qtdFolha(&(*sub_raiz)->ptrDireita); else return qtdFolha(&(*sub_raiz)->ptrDireita) + qtdFolha(&(*sub_raiz)->ptrEsquerda); } else return 0; } int qtdNull(tipo_no_arvore sub_raiz){ if (*sub_raiz !=NULL) { return qtdNull(&(*sub_raiz)->ptrEsquerda)+qtdNull(&(*sub_raiz)->ptrDireita); } else return 1; } int altura(tipo_no_arvore sub_raiz){ if (*sub_raiz !=NULL) { if( altura(&((*sub_raiz)->ptrEsquerda)) > altura(&((*sub_raiz)->ptrDireita))) return 1+altura(&(*sub_raiz)->ptrEsquerda); else return 1+altura(&(*sub_raiz)->ptrDireita); } return 0; } void copiarArvore(tipo_no_arvore sub_raiz_original, tipo_no_arvore sub_raiz_copia){ if(*sub_raiz_original!=NULL){ incluir_no_arvore(sub_raiz_copia,(*sub_raiz_original)->chave); copiarArvore(&((*sub_raiz_original)->ptrDireita),sub_raiz_copia); copiarArvore(&((*sub_raiz_original)->ptrEsquerda),sub_raiz_copia); } }

raquelsilvabelmiro@gmail.com

9b15002d5bd412d9ae808f94e24062e867912908

79b2d3126476fe7c997ebc5b8f0a1298b34630fd

/PROG/Sem1/Lab4/logo.h

f18a8f5846e8655b25d16b0468fe9ed466ff3075

no_license

DenisVasenin/Labs

13ba28d4c29cbe8899cd20ac9cc1f1dbdd825659

4b96ea12987d2a0046f58fe8b6d36e775769233b

refs/heads/master

UTF-8

C

h

int logo() { puts(""); puts(" ============================"); puts(" "); puts(" XX XX YY YY NN NN "); puts(" XXXX YYYY NNNN NN "); puts(" XX YY NN NN NN "); puts(" XXXX YY NN NNNN "); puts(" XX XX YY NN NN "); puts(" "); puts(" "); puts(" Пенкин Станислав гр ИВТ-11 "); puts(" "); puts(" ============================"); puts(""); return(0); }

ps.smartbox@gmail.com

a2ee19d7d87b6949e20292b2a52ca26dc7dd75dd

0b98befdd49f707ed1923703bcdac9740bb4d699

/priv/codegolf/Draw the Sawtooth Alphabet.c

de85b8d2d1997998ac9bef46d8908dbbd40b99cb

no_license

jbebe/all-my-projects

a957f2ae70d3ca09d49e1efc52c3cd9f6f786094

32a8b12b17d48c0138005eb54cb1ed9745baa737

refs/heads/master

UTF-8

C

c

/* A simple one today. Write the shortest program that draws a "sawtooth alphabet" given a positive integer for the height. You must write the name of your programming language when you come to the letter it starts with. For example, if your language is Python and the input is 1 the output should be: ABCDEFGHIJKLMNOPythonQRSTUVWXYZ If the input is 2 the output should be: B D F H J L N Python R T V X Z A C E G I K M O Q S U W Y If the input is 4 the output should be: D J Python V C E I K O Q U W B F H L N R T X Z A G M S Y */ /* if n holds the height: */ // C + escape codes: 81 x;main(y){for(y=n--;x<26;x++)printf("\033[%d;%dH%c",n?x/n&1?y++:y--:y,x+1,x+65);} // C 110 x;char a[702]={[0 ...701]=32};main(y){for(y=--n;x<26;a[x*27-1]=10)a[27*(n?x/n&1?y++:y--:y)+x]=x+++65;puts(a);}

juhasz.balint.bebe@gmail.com

a6268cf05d542102a4e024b55ddb4478cd60d8ce

e250176d7fc2d1d1ac604aa843543afe91e8843e

/chapter1/fold.c

0e37e96d78aa3e77a5172cc49be766743550f4ba

no_license

alicewriteswrongs/programminginc

3ea2ebd1a4622856eecb1b49e8011d5fb2cc4ed8

69f17bfede6ccfea70677eb06c6dd76305429ca8

refs/heads/master

UTF-8

C

c

#include <stdio.h> /* this is program to 'fold' long lines onto two lines, and I think we're going to do 80 * characters/line * */ #define MAXLINE 1000 // not going to bother with lines longer than 1000 #define OUTPUTMAXLINE 1020 // longer incase input is actually 1000 characters #define SPLIT 79 // number of characters per output line (indexed from 0, so 79 == 80 characters per line int mygetline(char line[], int maxline); void foldit(char old[], char new[], int length); main() { int lim = MAXLINE; int len; char before[MAXLINE]; char after[OUTPUTMAXLINE]; while ((len = mygetline(before, lim)) > 0) { foldit(before,after,len); printf("%s", after); } } int mygetline(char before[], int maxline) { int c, i; for (i = 0; i < maxline && (c = getchar()) != EOF && c != '\n'; i++) before[i] = c; if (c == '\n') { before[i] = c; i++; } before[i] = '\0'; return i; } void foldit(char old[], char new[], int length) { int i, offset, count; offset = count = 0; for (i = 0; i <= length; i++) { if (count != SPLIT) { new[i+offset] = old[i]; count += 1; } else if (count == SPLIT) { new[i+offset] = old[i]; offset += 1; new[i+offset] = '\n'; count = 0; } } } // I think it works! hahahaha!

alice.writes.wrongs@gmail.com

ad6c47c43213451cd6735ee31d3b8c2cb5b854d4

fd0137df01992ad3153ba9658e71e6c763760b7f

/Emu48/DDESERV.C

6478426a222253dd6a1def7b7c0fb139a99e39fc

no_license

tolkien/Emu48

b22a61dc952d70f9fd93e32a9a8a95c103f96e4b

777d5a9c399f4b2d800e8376bf2e62431bda71a0

refs/heads/master

ISO-8859-1

C

c

/* * DdeServ.c * * This file is part of Emu48 * * Copyright (C) 1998 Christoph Gießelink * */ #include "pch.h" #include "Emu48.h" #include "io.h" HDDEDATA CALLBACK DdeCallback(UINT iType,UINT iFmt,HCONV hConv, HSZ hsz1,HSZ hsz2,HDDEDATA hData, DWORD dwData1,DWORD dwData2) { TCHAR *psz,szBuffer[32]; HDDEDATA hReturn; LPBYTE lpData,lpHeader; DWORD dwAddress,dwSize,dwLoop,dwIndex; UINT nStkLvl; BOOL bSuccess; // disable stack loading items on HP38G, HP39/40G BOOL bStackEnable = cCurrentRomType!='6' && cCurrentRomType!='A' && cCurrentRomType!='E'; switch (iType) { case XTYP_CONNECT: // get service name DdeQueryString(idDdeInst,hsz2,szBuffer,ARRAYSIZEOF(szBuffer),0); if (0 != lstrcmp(szBuffer,szAppName)) return (HDDEDATA) FALSE; // get topic name DdeQueryString(idDdeInst,hsz1,szBuffer,ARRAYSIZEOF(szBuffer),0); return (HDDEDATA) (INT_PTR) (0 == lstrcmp(szBuffer,szTopic)); case XTYP_POKE: // quit on models without stack or illegal data format or not in running state if (!bStackEnable || iFmt != uCF_HpObj || nState != SM_RUN) return (HDDEDATA) DDE_FNOTPROCESSED; // get item name DdeQueryString(idDdeInst,hsz2,szBuffer,ARRAYSIZEOF(szBuffer),0); nStkLvl = _tcstoul(szBuffer,&psz,10); if (*psz != 0 || nStkLvl < 1) // invalid number format return (HDDEDATA) DDE_FNOTPROCESSED; SuspendDebugger(); // suspend debugger bDbgAutoStateCtrl = FALSE; // disable automatic debugger state control if (!(Chipset.IORam[BITOFFSET]&DON)) // HP off { // turn on HP KeyboardEvent(TRUE,0,0x8000); Sleep(dwWakeupDelay); KeyboardEvent(FALSE,0,0x8000); } if (WaitForSleepState()) // wait for cpu SHUTDN then sleep state { hReturn = DDE_FNOTPROCESSED; goto cancel; } while (nState!=nNextState) Sleep(0); _ASSERT(nState==SM_SLEEP); bSuccess = FALSE; // get data and size lpData = DdeAccessData(hData,&dwSize); // has object length header if (lpData && dwSize >= sizeof(DWORD)) { dwIndex = *(LPDWORD) lpData; // object length if (dwIndex <= dwSize - sizeof(DWORD)) { // reserve unpacked object length memory LPBYTE pbyMem = (LPBYTE) malloc(dwIndex * 2); if (pbyMem != NULL) { // copy data and write to stack CopyMemory(pbyMem+dwIndex,lpData+sizeof(DWORD),dwIndex); bSuccess = (WriteStack(nStkLvl,pbyMem,dwIndex) == S_ERR_NO); free(pbyMem); // free memory } } } DdeUnaccessData(hData); SwitchToState(SM_RUN); // run state while (nState!=nNextState) Sleep(0); _ASSERT(nState==SM_RUN); if (bSuccess == FALSE) { hReturn = DDE_FNOTPROCESSED; goto cancel; } KeyboardEvent(TRUE,0,0x8000); Sleep(dwWakeupDelay); KeyboardEvent(FALSE,0,0x8000); // wait for sleep mode while (Chipset.Shutdn == FALSE) Sleep(0); hReturn = (HDDEDATA) DDE_FACK; cancel: bDbgAutoStateCtrl = TRUE; // enable automatic debugger state control ResumeDebugger(); return hReturn; case XTYP_REQUEST: // quit on models without stack or illegal data format or not in running state if (!bStackEnable || iFmt != uCF_HpObj || nState != SM_RUN) return NULL; // get item name DdeQueryString(idDdeInst,hsz2,szBuffer,ARRAYSIZEOF(szBuffer),0); nStkLvl = _tcstoul(szBuffer,&psz,10); if (*psz != 0 || nStkLvl < 1) // invalid number format return NULL; if (WaitForSleepState()) // wait for cpu SHUTDN then sleep state return NULL; while (nState!=nNextState) Sleep(0); _ASSERT(nState==SM_SLEEP); dwAddress = RPL_Pick(nStkLvl); // pick address of stack level "item" object if (dwAddress == 0) { SwitchToState(SM_RUN); // run state return NULL; } dwLoop = dwSize = (RPL_SkipOb(dwAddress) - dwAddress + 1) / 2; lpHeader = (Chipset.type != 'X') ? (LPBYTE) BINARYHEADER48 : (LPBYTE) BINARYHEADER49; // length of binary header dwIndex = (DWORD) strlen((LPCSTR) lpHeader); // size of objectsize + header + object dwSize += dwIndex + sizeof(DWORD); // reserve memory if ((lpData = (LPBYTE) malloc(dwSize)) == NULL) { SwitchToState(SM_RUN); // run state return NULL; } // save data length *(DWORD *)lpData = dwLoop + dwIndex; // copy header memcpy(lpData + sizeof(DWORD),lpHeader,dwIndex); // copy data for (dwIndex += sizeof(DWORD);dwLoop--;++dwIndex,dwAddress += 2) lpData[dwIndex] = Read2(dwAddress); // write data hReturn = DdeCreateDataHandle(idDdeInst,lpData,dwSize,0,hsz2,iFmt,0); free(lpData); SwitchToState(SM_RUN); // run state while (nState!=nNextState) Sleep(0); _ASSERT(nState==SM_RUN); return hReturn; } return NULL; UNREFERENCED_PARAMETER(hConv); UNREFERENCED_PARAMETER(dwData1); UNREFERENCED_PARAMETER(dwData2); }

ryanbee@microsoft.com

e4ca123d176646b4ad4c5e6601e1ec61881ef2b6

eb127d545b1aa5d4f6dfe7b900613678a061ed8e

/clip/libclipmain/_util/clip_CLIP_HOSTCS.c

68fd4dedfca7aaaf9947cfc9d259df1827c1ab7f

no_license

amery/clip-angelo

a41fccb525b2fb311b2e179508b8ec50457ee7ae

556fb1d40645d4c8fc33cda4014ab31a5b6500ea

refs/heads/master

UTF-8

C

c

int clip_CLIP_HOSTCS(ClipMachine * ClipMachineMemory) { _clip_retc(ClipMachineMemory, _clip_hostcs); return 0; }

amery@geeks.cl

f3aba8ef613f6ee571dcd7583931e508a0734276

99bdb3251fecee538e0630f15f6574054dfc1468

/bsp/lm3s8962/Libraries/driverlib/lpc.h

15023178da16496a198e68242b6002c3aa35a2e2

permissive

RT-Thread/rt-thread

03a7c52c2aeb1b06a544143b0e803d72f47d1ece

3602f891211904a27dcbd51e5ba72fefce7326b2

refs/heads/master

Apache-2.0

C

UTF-8

C

h

//***************************************************************************** // // lpc.h - Prototypes for the Low Pin Count (LPC) driver. // // Copyright (c) 2010-2011 Texas Instruments Incorporated. All rights reserved. // Software License Agreement // // Texas Instruments (TI) is supplying this software for use solely and // exclusively on TI's microcontroller products. The software is owned by // TI and/or its suppliers, and is protected under applicable copyright // laws. You may not combine this software with "viral" open-source // software in order to form a larger program. // // THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. // NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT // NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY // CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL // DAMAGES, FOR ANY REASON WHATSOEVER. // // This is part of revision 8264 of the Stellaris Peripheral Driver Library. // //***************************************************************************** #ifndef __LPC_H__ #define __LPC_H__ //***************************************************************************** // // If building with a C++ compiler, make all of the definitions in this header // have a C binding. // //***************************************************************************** #ifdef __cplusplus extern "C" { #endif //***************************************************************************** // // Values that can be passed to LPCConfigSet as the ulConfig value, and // returned from LPCConfigGet. // //***************************************************************************** #define LPC_CFG_WAKE 0x00000100 // Restart the LPC Bus //***************************************************************************** // // Values that can be returned from LPCStatus. // //***************************************************************************** #define LPC_STATUS_RST 0x00000400 // LPC is in Reset #define LPC_STATUS_BUSY 0x00000200 // LPC is Busy #define LPC_STATUS_SLEEP 0x00000100 // LPC is in Sleep Mode #define LPC_STATUS_CA7 0x00000080 // Channel 7 Active #define LPC_STATUS_CA6 0x00000040 // Channel 6 Active #define LPC_STATUS_CA5 0x00000020 // Channel 5 Active #define LPC_STATUS_CA4 0x00000010 // Channel 4 Active #define LPC_STATUS_CA3 0x00000008 // Channel 3 Active #define LPC_STATUS_CA2 0x00000004 // Channel 2 Active #define LPC_STATUS_CA1 0x00000002 // Channel 1 Active #define LPC_STATUS_CA0 0x00000001 // Channel 0 Active //***************************************************************************** // // Values that can be passed to LPCIRQSet and LPCIRQClear in the ulIRQ // parameter and returned from LPCIRQGet. // //***************************************************************************** #define LPC_IRQ15 0x80000000 // Serial IRQ15 #define LPC_IRQ14 0x40000000 // Serial IRQ14 #define LPC_IRQ13 0x20000000 // Serial IRQ13 #define LPC_IRQ12 0x10000000 // Serial IRQ12 #define LPC_IRQ11 0x08000000 // Serial IRQ11 #define LPC_IRQ10 0x04000000 // Serial IRQ10 #define LPC_IRQ9 0x02000000 // Serial IRQ9 #define LPC_IRQ8 0x01000000 // Serial IRQ8 #define LPC_IRQ7 0x00800000 // Serial IRQ7 #define LPC_IRQ6 0x00400000 // Serial IRQ6 #define LPC_IRQ5 0x00200000 // Serial IRQ5 #define LPC_IRQ4 0x00100000 // Serial IRQ4 #define LPC_IRQ3 0x00080000 // Serial IRQ3 #define LPC_IRQ2 0x00040000 // Serial IRQ2 #define LPC_IRQ1 0x00020000 // Serial IRQ1 #define LPC_IRQ0 0x00010000 // Serial IRQ0 //***************************************************************************** // // Addition values that can be returned from LPCIRQGet. // //***************************************************************************** #define LPC_IRQ_BUSY 0x00000004 // SERIRQ frame in progress #define LPC_IRQ_CONT 0x00000001 // SERIRQ in Continuous Mode //***************************************************************************** // // Values that can be passed as the ulChannel parameter in LPCChannel... // API calls. // //***************************************************************************** #define LPC_CHAN_CH0 0 // LPC Channel 0 #define LPC_CHAN_CH1 1 // LPC Channel 1 #define LPC_CHAN_CH2 2 // LPC Channel 2 #define LPC_CHAN_CH3 3 // LPC Channel 3 #define LPC_CHAN_CH4 4 // LPC Channel 4 #define LPC_CHAN_CH5 5 // LPC Channel 5 #define LPC_CHAN_CH6 6 // LPC Channel 6 #define LPC_CHAN_CH7 7 // LPC Channel 7 (COMx) #define LPC_CHAN_COMx 7 // LPC Channel 7 (COMx) //***************************************************************************** // // Values that can be passed as part of the ulConfig parameter in the // LPCChannelConfig... functions. // //***************************************************************************** #define LPC_CHAN_IRQSEL2_NONE 0x00000000 // LPC Channel IRQSEL2 Disabled #define LPC_CHAN_IRQSEL2_IRQ0 0x00080000 // LPC Channel IRQSEL2 IRQ0 #define LPC_CHAN_IRQSEL2_IRQ1 0x10080000 // LPC Channel IRQSEL2 IRQ1 #define LPC_CHAN_IRQSEL2_IRQ2 0x20080000 // LPC Channel IRQSEL2 IRQ2 #define LPC_CHAN_IRQSEL2_IRQ3 0x30080000 // LPC Channel IRQSEL2 IRQ3 #define LPC_CHAN_IRQSEL2_IRQ4 0x40080000 // LPC Channel IRQSEL2 IRQ4 #define LPC_CHAN_IRQSEL2_IRQ5 0x50080000 // LPC Channel IRQSEL2 IRQ5 #define LPC_CHAN_IRQSEL2_IRQ6 0x60080000 // LPC Channel IRQSEL2 IRQ6 #define LPC_CHAN_IRQSEL2_IRQ7 0x70080000 // LPC Channel IRQSEL2 IRQ7 #define LPC_CHAN_IRQSEL2_IRQ8 0x80080000 // LPC Channel IRQSEL2 IRQ8 #define LPC_CHAN_IRQSEL2_IRQ9 0x90080000 // LPC Channel IRQSEL2 IRQ9 #define LPC_CHAN_IRQSEL2_IRQ10 0xA0080000 // LPC Channel IRQSEL2 IRQ10 #define LPC_CHAN_IRQSEL2_IRQ11 0xB0080000 // LPC Channel IRQSEL2 IRQ11 #define LPC_CHAN_IRQSEL2_IRQ12 0xC0080000 // LPC Channel IRQSEL2 IRQ12 #define LPC_CHAN_IRQSEL2_IRQ13 0xD0080000 // LPC Channel IRQSEL2 IRQ13 #define LPC_CHAN_IRQSEL2_IRQ14 0xE0080000 // LPC Channel IRQSEL2 IRQ14 #define LPC_CHAN_IRQSEL2_IRQ15 0xF0080000 // LPC Channel IRQSEL2 IRQ15 #define LPC_CHAN_COMxIRQ_DISABLE \ 0x00000000 // LCP Channel COMx IRQ Disabled #define LPC_CHAN_COMxIRQ_ENABLE 0x00080000 // LCP Channel COMx IRQ Enabled #define LPC_CHAN_IRQSEL1_NONE 0x00000000 // LPC Channel IRQSEL1 Disabled #define LPC_CHAN_IRQSEL1_IRQ0 0x00040000 // LPC Channel IRQSEL1 IRQ0 #define LPC_CHAN_IRQSEL1_IRQ1 0x01040000 // LPC Channel IRQSEL1 IRQ1 #define LPC_CHAN_IRQSEL1_IRQ2 0x02040000 // LPC Channel IRQSEL1 IRQ2 #define LPC_CHAN_IRQSEL1_IRQ3 0x03040000 // LPC Channel IRQSEL1 IRQ3 #define LPC_CHAN_IRQSEL1_IRQ4 0x04040000 // LPC Channel IRQSEL1 IRQ4 #define LPC_CHAN_IRQSEL1_IRQ5 0x05040000 // LPC Channel IRQSEL1 IRQ5 #define LPC_CHAN_IRQSEL1_IRQ6 0x06040000 // LPC Channel IRQSEL1 IRQ6 #define LPC_CHAN_IRQSEL1_IRQ7 0x07040000 // LPC Channel IRQSEL1 IRQ7 #define LPC_CHAN_IRQSEL1_IRQ8 0x08040000 // LPC Channel IRQSEL1 IRQ8 #define LPC_CHAN_IRQSEL1_IRQ9 0x09040000 // LPC Channel IRQSEL1 IRQ9 #define LPC_CHAN_IRQSEL1_IRQ10 0x0A040000 // LPC Channel IRQSEL1 IRQ10 #define LPC_CHAN_IRQSEL1_IRQ11 0x0B040000 // LPC Channel IRQSEL1 IRQ11 #define LPC_CHAN_IRQSEL1_IRQ12 0x0C040000 // LPC Channel IRQSEL1 IRQ12 #define LPC_CHAN_IRQSEL1_IRQ13 0x0D040000 // LPC Channel IRQSEL1 IRQ13 #define LPC_CHAN_IRQSEL1_IRQ14 0x0E040000 // LPC Channel IRQSEL1 IRQ14 #define LPC_CHAN_IRQSEL1_IRQ15 0x0F040000 // LPC Channel IRQSEL1 IRQ15 #define LPC_CHAN_IRQSEL0_NONE 0x00000000 // LPC Channel IRQSEL0 Disabled #define LPC_CHAN_IRQSEL0_IRQ0 0x00000000 // LPC Channel IRQSEL0 IRQ0 #define LPC_CHAN_IRQSEL0_IRQ1 0x00100000 // LPC Channel IRQSEL0 IRQ1 #define LPC_CHAN_IRQSEL0_IRQ2 0x00200000 // LPC Channel IRQSEL0 IRQ2 #define LPC_CHAN_IRQSEL0_IRQ3 0x00300000 // LPC Channel IRQSEL0 IRQ3 #define LPC_CHAN_IRQSEL0_IRQ4 0x00400000 // LPC Channel IRQSEL0 IRQ4 #define LPC_CHAN_IRQSEL0_IRQ5 0x00500000 // LPC Channel IRQSEL0 IRQ5 #define LPC_CHAN_IRQSEL0_IRQ6 0x00600000 // LPC Channel IRQSEL0 IRQ6 #define LPC_CHAN_IRQSEL0_IRQ7 0x00700000 // LPC Channel IRQSEL0 IRQ7 #define LPC_CHAN_IRQSEL0_IRQ8 0x00800000 // LPC Channel IRQSEL0 IRQ8 #define LPC_CHAN_IRQSEL0_IRQ9 0x00900000 // LPC Channel IRQSEL0 IRQ9 #define LPC_CHAN_IRQSEL0_IRQ10 0x00A00000 // LPC Channel IRQSEL0 IRQ10 #define LPC_CHAN_IRQSEL0_IRQ11 0x00B00000 // LPC Channel IRQSEL0 IRQ11 #define LPC_CHAN_IRQSEL0_IRQ12 0x00C00000 // LPC Channel IRQSEL0 IRQ12 #define LPC_CHAN_IRQSEL0_IRQ13 0x00D00000 // LPC Channel IRQSEL0 IRQ13 #define LPC_CHAN_IRQSEL0_IRQ14 0x00E00000 // LPC Channel IRQSEL0 IRQ14 #define LPC_CHAN_IRQSEL0_IRQ15 0x00F00000 // LPC Channel IRQSEL0 IRQ15 #define LPC_CHAN_IRQEN0_OFF 0x00000000 // LPC Channel IRQEN0 Disabled #define LPC_CHAN_IRQEN0_TRG1 0x00010000 // LPC Channel IRQEN0 Trigger 1 #define LPC_CHAN_IRQEN0_TRG2 0x00020000 // LPC Channel IRQEN0 Trigger 2 #define LPC_CHAN_IRQEN0_TRG3 0x00030000 // LPC Channel IRQEN0 Trigger 3 #define LPC_CHAN_MBARB_ENABLED 0x00000000 // LPC Channel Mailbox Arbritration // enabled. #define LPC_CHAN_MBARB_DISABLED 0x00008000 // LPC Channel Mailbox Arbritration // disabled. #define LPC_CHAN_SIZE_4 0x00000000 // Mailbox IO/Memory Window size // is 4 Bytes. #define LPC_CHAN_SIZE_8 0x00000004 // Mailbox IO/Memory Window size // is 4 Bytes. #define LPC_CHAN_SIZE_16 0x00000008 // Mailbox IO/Memory Window size // is 4 Bytes. #define LPC_CHAN_SIZE_32 0x0000000C // Mailbox IO/Memory Window size // is 4 Bytes. #define LPC_CHAN_SIZE_64 0x00000010 // Mailbox IO/Memory Window size // is 4 Bytes. #define LPC_CHAN_SIZE_128 0x00000014 // Mailbox IO/Memory Window size // is 4 Bytes. #define LPC_CHAN_SIZE_256 0x00000018 // Mailbox IO/Memory Window size // is 4 Bytes. #define LPC_CHAN_SIZE_512 0x0000001C // Mailbox IO/Memory Window size // is 4 Bytes. //***************************************************************************** // // Values that can be passed to LCPChannelConfigCOMxSet as the ulCOMxMode // parameter or returned from LPCChannelConfigGet in the pulCOMxMode // parameter. // //***************************************************************************** #define LPC_COMx_MODE_FRMHNML 0x00000000 // Normal From Host model. #define LPC_COMx_MODE_FRMHIGN 0x00020000 // Ignore From Host data. #define LPC_COMx_MODE_FRMHDMA 0x00040000 // COMx DMA on From Host data to // memory #define LPC_COMx_MODE_UARTDMA 0x00060000 // COMx DMA on From Host data to // UART1 //***************************************************************************** // // Additinal values that can be returned from LPCChannelConfigGet in the // pulCOMxMode parameter. // //***************************************************************************** #define LPC_COMx_ENABLED 0x00010000 // COMx mode enabled. //***************************************************************************** // // Values that can be passed to LPCIntEnable, LPCIntDisable, and LPCIntClear // as the ulIntFlags parameter and returned by LPCIntStatus. // //***************************************************************************** #define LPC_INT_RST 0x80000000 // LPC Bus Enters or Exits // Reset State. #define LPC_INT_SLEEP 0x40000000 // LPC Bus Enters or Exits // Sleep State. #define LPC_INT_COMx 0x20000000 // COMx has read/written // data. #define LPC_INT_SIRQ 0x10000000 // SERIRQ frame has completed #define LPC_INT_CH6_EP_TO_HOST (1 << 24) // To-Host has been read. #define LPC_INT_CH6_EP_FROM_DATA \ (2 << 24) // From-Host has been written as // data. #define LPC_INT_CH6_EP_FROM_CMD (4 << 24) // From-Host has been written as // command. #define LPC_INT_CH6_MB_HOST_WON (1 << 24) // Host Won (HW1ST) #define LPC_INT_CH6_MB_HOST_WRITE \ (2 << 24) // Host Wrote Last Byte. #define LPC_INT_CH6_MB_HOST_READ \ (4 << 24) // Host Read Last Byte #define LPC_INT_CH6_MB_MCU_LOST (8 << 24) // MCU Lost (when host had HW1ST). #define LPC_INT_CH5_EP_TO_HOST (1 << 20) // To-Host has been read. #define LPC_INT_CH5_EP_FROM_DATA \ (2 << 20) // From-Host has been written as // data. #define LPC_INT_CH5_EP_FROM_CMD (4 << 20) // From-Host has been written as // command. #define LPC_INT_CH5_MB_HOST_WON (1 << 20) // Host Won (HW1ST) #define LPC_INT_CH5_MB_HOST_WRITE \ (2 << 20) // Host Wrote Last Byte. #define LPC_INT_CH5_MB_HOST_READ \ (4 << 20) // Host Read Last Byte #define LPC_INT_CH5_MB_MCU_LOST (8 << 20) // MCU Lost (when host had HW1ST). #define LPC_INT_CH4_EP_TO_HOST (1 << 16) // To-Host has been read. #define LPC_INT_CH4_EP_FROM_DATA \ (2 << 16) // From-Host has been written as // data. #define LPC_INT_CH4_EP_FROM_CMD (4 << 16) // From-Host has been written as // command. #define LPC_INT_CH4_MB_HOST_WON (1 << 16) // Host Won (HW1ST) #define LPC_INT_CH4_MB_HOST_WRITE \ (2 << 16) // Host Wrote Last Byte. #define LPC_INT_CH4_MB_HOST_READ \ (4 << 16) // Host Read Last Byte #define LPC_INT_CH4_MB_MCU_LOST (8 << 16) // MCU Lost (when host had HW1ST). #define LPC_INT_CH3_EP_TO_HOST (1 << 12) // To-Host has been read. #define LPC_INT_CH3_EP_FROM_DATA \ (2 << 12) // From-Host has been written as // data. #define LPC_INT_CH3_EP_FROM_CMD (4 << 12) // From-Host has been written as // command. #define LPC_INT_CH3_MB_HOST_WON (1 << 12) // Host Won (HW1ST) #define LPC_INT_CH3_MB_HOST_WRITE \ (2 << 12) // Host Wrote Last Byte. #define LPC_INT_CH3_MB_HOST_READ \ (4 << 12) // Host Read Last Byte #define LPC_INT_CH3_MB_MCU_LOST (8 << 12) // MCU Lost (when host had HW1ST). #define LPC_INT_CH2_EP_TO_HOST (1 << 8) // To-Host has been read. #define LPC_INT_CH2_EP_FROM_DATA \ (2 << 8) // From-Host has been written as // data. #define LPC_INT_CH2_EP_FROM_CMD (4 << 8) // From-Host has been written as // command. #define LPC_INT_CH2_MB_HOST_WON (1 << 8) // Host Won (HW1ST) #define LPC_INT_CH2_MB_HOST_WRITE \ (2 << 8) // Host Wrote Last Byte. #define LPC_INT_CH2_MB_HOST_READ \ (4 << 8) // Host Read Last Byte #define LPC_INT_CH2_MB_MCU_LOST (8 << 8) // MCU Lost (when host had HW1ST). #define LPC_INT_CH1_EP_TO_HOST (1 << 4) // To-Host has been read. #define LPC_INT_CH1_EP_FROM_DATA \ (2 << 4) // From-Host has been written as // data. #define LPC_INT_CH1_EP_FROM_CMD (4 << 4) // From-Host has been written as // command. #define LPC_INT_CH1_MB_HOST_WON (1 << 4) // Host Won (HW1ST) #define LPC_INT_CH1_MB_HOST_WRITE \ (2 << 4) // Host Wrote Last Byte. #define LPC_INT_CH1_MB_HOST_READ \ (4 << 4) // Host Read Last Byte #define LPC_INT_CH1_MB_MCU_LOST (8 << 4) // MCU Lost (when host had HW1ST). #define LPC_INT_CH0_EP_TO_HOST (1 << 0) // To-Host has been read. #define LPC_INT_CH0_EP_FROM_DATA \ (2 << 0) // From-Host has been written as // data. #define LPC_INT_CH0_EP_FROM_CMD (4 << 0) // From-Host has been written as // command. #define LPC_INT_CH0_MB_HOST_WON (1 << 0) // Host Won (HW1ST) #define LPC_INT_CH0_MB_HOST_WRITE \ (2 << 0) // Host Wrote Last Byte. #define LPC_INT_CH0_MB_HOST_READ \ (4 << 0) // Host Read Last Byte #define LPC_INT_CH0_MB_MCU_LOST (8 << 0) // MCU Lost (when host had HW1ST). //***************************************************************************** // // Values that can be passed to LPCCOMxInt... functions as the ulIntFlags // parameter and returned by LPCIntStatus. // //***************************************************************************** #define LPC_COMx_INT_CX 0x02000000 // Raw Event State for COMx #define LPC_COMx_INT_CXTX 0x01000000 // Raw Event State for COMx TX #define LPC_COMx_INT_CXRX 0x00800000 // Raw Event State for COMx RX #define LPC_COMx_MASK_CX 0x00200000 // Event Mask for COMx #define LPC_COMx_MASK_CXTX 0x00100000 // Event Mask for COMx TX #define LPC_COMx_MASK_CXRX 0x00080000 // Event Mask for COMx RX //***************************************************************************** // // Values that can be passed to the LPCChannelDMAConfigSet function as part // of the ulConfig or ulMask parameter, or can be returned from the // LPCChannelConfigGet function. // //***************************************************************************** #define LPC_DMA_CH3_WEN 0x00000080 // Trigger DMA for "To Host" data // buffer is empty. #define LPC_DMA_CH3_REN 0x00000040 // Trigger DMA when "From Host" // data buffer is full. #define LPC_DMA_CH2_WEN 0x00000020 // Trigger DMA for "To Host" data // buffer is empty. #define LPC_DMA_CH2_REN 0x00000010 // Trigger DMA when "From Host" // data buffer is full. #define LPC_DMA_CH1_WEN 0x00000008 // Trigger DMA for "To Host" data // buffer is empty. #define LPC_DMA_CH1_REN 0x00000004 // Trigger DMA when "From Host" // data buffer is full. #define LPC_DMA_CH0_WEN 0x00000002 // Trigger DMA for "To Host" data // buffer is empty. #define LPC_DMA_CH0_REN 0x00000001 // Trigger DMA when "From Host" // data buffer is full. //***************************************************************************** // // Values that can be passed to the LPCChannelStatusSet and // LPCChannelStatusClear function, and returned by the LPCChannelStatusGet // function. // //***************************************************************************** #define LPC_CH_ST_USER0 0x00000100 // User Status Bit 0 #define LPC_CH_ST_USER1 0x00000200 // User Status Bit 1 #define LPC_CH_ST_USER2 0x00000400 // User Status Bit 2 #define LPC_CH_ST_USER3 0x00000800 // User Status Bit 3 #define LPC_CH_ST_USER4 0x00001000 // User Status Bit 4 //***************************************************************************** // // Additinoal values that can be returned by the LPCChannelStatusGet function. // //***************************************************************************** #define LPC_CH_ST_LASTHW 0x00000080 // Last Host Write #define LPC_CH_ST_HW1ST 0x00000040 // First Host Write #define LPC_CH_ST_LASTSW 0x00000020 // Last Slave Write #define LPC_CH_ST_SW1ST 0x00000010 // First Slave Write #define LPC_CH_ST_CMD 0x00000008 // Command or Data #define LPC_CH_ST_FRMH 0x00000002 // From-Host Transaction #define LPC_CH_ST_TOH 0x00000001 // To-Host Transaction //***************************************************************************** // // Prototypes for the APIs. // //***************************************************************************** extern void LPCConfigSet(unsigned long ulBase, unsigned long ulConfig); extern unsigned long LPCConfigGet(unsigned long ulBase); extern unsigned long LPCStatusGet(unsigned long ulBase, unsigned long *pulCount, unsigned long *pulPoolSize); extern void LPCStatusBlockAddressSet(unsigned long ulBase, unsigned long ulAddress, tBoolean bEnabled); extern unsigned LPCStatusBlockAddressGet(unsigned long ulBase); extern void LPCSCIAssert(unsigned long ulBase, unsigned long ulCount); extern void LPCIRQConfig(unsigned long ulBase, tBoolean bIRQPulse, tBoolean bIRQOnChange); extern void LPCIRQSet(unsigned long ulBase, unsigned long ulIRQ); extern void LPCIRQClear(unsigned long ulBase, unsigned long ulIRQ); extern unsigned long LPCIRQGet(unsigned long ulBase); extern void LPCIRQSend(unsigned long ulBase); extern void LPCIntRegister(unsigned long ulBase, void (*pfnHandler)(void)); extern void LPCIntUnregister(unsigned long ulBase); extern void LPCIntEnable(unsigned long ulBase, unsigned long ulIntFlags); extern void LPCIntDisable(unsigned long ulBase, unsigned long ulIntFlags); extern unsigned long LPCIntStatus(unsigned long ulBase, tBoolean bMasked); extern void LPCIntClear(unsigned long ulBase, unsigned long ulIntFlags); extern void LPCChannelEnable(unsigned long ulBase, unsigned long ulChannel); extern void LPCChannelDisable(unsigned long ulBase, unsigned long ulChannel); extern void LPCChannelConfigEPSet(unsigned long ulBase, unsigned long ulChannel, unsigned long ulConfig, unsigned long ulAddress, unsigned long ulOffset); extern void LPCChannelConfigMBSet(unsigned long ulBase, unsigned long ulChannel, unsigned long ulConfig, unsigned long ulAddress, unsigned long ulOffset); extern void LPCChannelConfigCOMxSet(unsigned long ulBase, unsigned long ulChannel, unsigned long ulConfig, unsigned long ulAddress, unsigned long ulOffset, unsigned long ulCOMxMode); extern unsigned long LPCChannelConfigGet(unsigned long ulBase, unsigned long ulChannel, unsigned long *pulAddress, unsigned long *pulOffset, unsigned long *pulCOMxMode); extern unsigned long LPCChannelPoolAddressGet(unsigned long ulBase, unsigned long ulChannel); extern unsigned long LPCChannelStatusGet(unsigned long ulBase, unsigned long ulChannel); extern void LPCChannelStatusSet(unsigned long ulBase, unsigned long ulChannel, unsigned long ulStatus); extern void LPCChannelStatusClear(unsigned long ulBase, unsigned long ulChannel, unsigned long ulStatus); extern void LPCChannelDMAConfigSet(unsigned long ulBase, unsigned long ulConfig, unsigned long ulMask); extern unsigned long LPCChannelDMAConfigGet(unsigned long ulBase); extern unsigned char LPCByteRead(unsigned long ulBase, unsigned long ulOffset); extern void LPCByteWrite(unsigned long ulBase, unsigned long ulOffset, unsigned char ucData); extern unsigned short LPCHalfWordRead(unsigned long ulBase, unsigned long ulOffset); extern void LPCHalfWordWrite(unsigned long ulBase, unsigned long ulOffset, unsigned short usData); extern unsigned long LPCWordRead(unsigned long ulBase, unsigned long ulOffset); extern void LPCWordWrite(unsigned long ulBase, unsigned long ulOffset, unsigned long ulData); extern void LPCCOMxIntEnable(unsigned long ulBase, unsigned long ulIntFlags); extern void LPCCOMxIntDisable(unsigned long ulBase, unsigned long ulIntFlags); extern unsigned long LPCCOMxIntStatus(unsigned long ulBase, tBoolean bMasked); extern void LPCCOMxIntClear(unsigned long ulBase, unsigned long ulIntFlags); //***************************************************************************** // // Mark the end of the C bindings section for C++ compilers. // //***************************************************************************** #ifdef __cplusplus } #endif #endif // __LPC_H__

mbbill@gmail.com

ba1e8d10b4304a881878387964db1a02e670c5d3

166fba38e48ca1968348f5a6fd8c435392d619db

/jzz.c

d1576d8fbf128a1060ae1ca5dd4b9ce9d27aea4e

no_license

Yuvpriya/jazz

0925c109f2f2652ed886f4cce0c0c362ff96ba5b

0e81454801892f6fc762f74cb15b363d8640c301

refs/heads/master

UTF-8

C

c

#include<stdio.h> #include<string.h> int main() { char p[20],q[20],r[20],i; scanf("%s",p); scanf("%s",r); scanf("%s",q); for(i=0;i<19;i++) { if((p[i]==q[i])&&(q[i]==r[i])) { printf("%c",p[i]); } else break; } return 0; }

noreply@github.com

872d8f0e8f79d8d3cc847d279d797bd59b047c8a

bfb77baec8635ec547dcab598fa537785a03d3fb

/MDK-ARM/Lora.c

f4632170ad1e6ae45ecaa5aa22ab3d9fc338799b

no_license

huynd98/SENSOR1_DATN

6fd4dc6eaae9665b738c86c31dd83b432823d140

6faedbe233ec30f4f1c79f0368cafcbe2a9ff678

refs/heads/main

UTF-8

C

c

#include "Lora.h" uint8_t readRegLora_8Bit(uint8_t address){ uint8_t result=0; HAL_GPIO_WritePin(GPIOA, LORA_NSS_Pin, GPIO_PIN_RESET); HAL_Delay(1); while ( HAL_SPI_Transmit(&hspi2,&address,1,100) != HAL_OK ); while ( HAL_SPI_Receive(&hspi2,&result,1,100) != HAL_OK ); HAL_GPIO_WritePin(GPIOA, LORA_NSS_Pin, GPIO_PIN_SET); return result; } /*****************************************************************/ void readRegLora(uint8_t address, uint8_t *receiveData, uint8_t length){ HAL_GPIO_WritePin(GPIOA, LORA_NSS_Pin, GPIO_PIN_RESET); HAL_Delay(1); while ( HAL_SPI_Transmit(&hspi2,&address,1,100) != HAL_OK ); while ( HAL_SPI_Receive(&hspi2,receiveData,length,100) != HAL_OK ); HAL_GPIO_WritePin(GPIOA, LORA_NSS_Pin, GPIO_PIN_SET); } /*****************************************************************/ void writeRegLora(uint8_t address, uint8_t data){ uint8_t add; add = address | 0x80; HAL_GPIO_WritePin(GPIOA, LORA_NSS_Pin, GPIO_PIN_RESET); HAL_Delay(1); while ( HAL_SPI_Transmit(&hspi2,&add,1,100) != HAL_OK ); while ( HAL_SPI_Transmit(&hspi2,&data,1,100) != HAL_OK ); HAL_GPIO_WritePin(GPIOA, LORA_NSS_Pin, GPIO_PIN_SET); } /*****************************************************************/ void writeToFIFO(uint8_t *data, uint8_t length){ uint8_t add= REG_FIFO | 0x80; HAL_GPIO_WritePin(GPIOA, LORA_NSS_Pin, GPIO_PIN_RESET); HAL_Delay(1); while ( HAL_SPI_Transmit(&hspi2,&add,1,100) != HAL_OK ); while ( HAL_SPI_Transmit(&hspi2,data,length,100) != HAL_OK ); HAL_GPIO_WritePin(GPIOA, LORA_NSS_Pin, GPIO_PIN_SET); } /*****************************************************************/ void LoraSetFreq(uint32_t frequency){ uint64_t frf = ((uint64_t)frequency << 19) / 32000000; writeRegLora(REG_FRF_MSB, (uint8_t)(frf >> 16)); writeRegLora(REG_FRF_MID, (uint8_t)(frf >> 8)); writeRegLora(REG_FRF_LSB, (uint8_t)(frf >> 0)); } /*****************************************************************/ void LoraSleep(void){ writeRegLora(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_SLEEP); } /*****************************************************************/ void LoraIdle(void){ writeRegLora(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_STDBY); } //********************************************************** uint16_t LoraBegin(void){ //Blink Reset Pin HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8,GPIO_PIN_SET); HAL_Delay(10); HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8,GPIO_PIN_RESET); HAL_Delay(10); HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8,GPIO_PIN_SET); HAL_Delay(10); //Blink Slave Selection HAL_GPIO_WritePin(GPIOA, LORA_NSS_Pin, GPIO_PIN_RESET); HAL_Delay(10); HAL_GPIO_WritePin(GPIOA, LORA_NSS_Pin, GPIO_PIN_SET); HAL_Delay(10); //Check Version uint8_t version = readRegLora_8Bit(REG_VERSION); if (version != 0x12) return 0; //put in sleep mode LoraSleep(); //Set Frequency LoraSetFreq(FREQUENCY); //Set base address FIFO writeRegLora(REG_FIFO_TX_BASE_ADDR, 0); writeRegLora(REG_FIFO_RX_BASE_ADDR, 0); //set explicitheader mode //writeRegLora(REG_MODEM_CONFIG_1, readRegLora_8Bit(REG_MODEM_CONFIG_1) & 0xfe); LoraExplicitHeaderMode(); // set LNA boost writeRegLora(REG_LNA, readRegLora_8Bit(REG_LNA) | 0x03); // set auto AGC writeRegLora(REG_MODEM_CONFIG_3, 0x04); //ocpTrim writeRegLora(REG_OCP, 0x20 | (0x1F & 0x0B)); //TX power writeRegLora(REG_PA_CONFIG, PA_BOOST | (17 - 2)); //put in standby Mode LoraIdle(); return 1; } //***************************************************** void LoraEnd(void){ LoraSleep(); } //**************************************************** void LoraSetLdoFlag(void){ // Section 4.1.1.5 long symbolDuration = 1000 / ( LoraGetSignalBW() / (1L << LoraGetSpreadingFactor()) ) ; uint8_t config3 = readRegLora_8Bit(REG_MODEM_CONFIG_3); // Section 4.1.1.6 if(symbolDuration > 16) config3 = config3 | 0x08; else config3 = config3 & 0xF7; // bitWrite(config3, 3, ldoOn); writeRegLora(REG_MODEM_CONFIG_3, config3); } //**************************************************** //set Spreading Factor void LoraSetSpreadingFactor(uint8_t sf){ if (sf < 6) { sf = 6; } else if (sf > 12) { sf = 12; } if (sf == 6) { writeRegLora(REG_DETECTION_OPTIMIZE, 0xc5); writeRegLora(REG_DETECTION_THRESHOLD, 0x0c); } else { writeRegLora(REG_DETECTION_OPTIMIZE, 0xc3); writeRegLora(REG_DETECTION_THRESHOLD, 0x0a); } writeRegLora(REG_MODEM_CONFIG_2, (readRegLora_8Bit(REG_MODEM_CONFIG_2) & 0x0f) | ((sf << 4) & 0xf0)); LoraSetLdoFlag(); } //****************************************************** uint16_t LoraGetSpreadingFactor(void){ return readRegLora_8Bit(REG_MODEM_CONFIG_2) >> 4; } //*************************************************** //get Signal Band Width uint32_t LoraGetSignalBW(void){ uint8_t bw = (readRegLora_8Bit(REG_MODEM_CONFIG_1) >> 4); switch (bw) { case 0: return 7800; case 1: return 10400; case 2: return 15600; case 3: return 20800; case 4: return 31250; case 5: return 41700; case 6: return 62500; case 7: return 125000; case 8: return 250000; case 9: return 500000; } return 0; } //***************************************************** //set Signal BandWidth void LoraSetSignalBW(uint32_t bandwidth){ int bw; if (bandwidth <= 7.8E3) { bw = 0; } else if (bandwidth <= 10400) { bw = 1; } else if (bandwidth <= 15600) { bw = 2; } else if (bandwidth <= 20800) { bw = 3; } else if (bandwidth <= 31250) { bw = 4; } else if (bandwidth <= 41700) { bw = 5; } else if (bandwidth <= 62500) { bw = 6; } else if (bandwidth <= 125000) { bw = 7; } else if (bandwidth <= 250000) { bw = 8; } else /*if (bandwidth <= 250E3)*/ { bw = 9; } writeRegLora(REG_MODEM_CONFIG_1, (readRegLora_8Bit(REG_MODEM_CONFIG_1) & 0x0f) | (bw << 4)); LoraSetLdoFlag(); } //******************************************************** //set Coding Rate void LoraSetCodingRate(int denominator){ if (denominator < 5) { denominator = 5; } else if (denominator > 8) { denominator = 8; } int cr = denominator - 4; writeRegLora(REG_MODEM_CONFIG_1, (readRegLora_8Bit(REG_MODEM_CONFIG_1) & 0xf1) | (cr << 1)); } //*********************************************************** //Lora is Transmitting uint8_t LoraIsTransmitting(void){ if ((readRegLora_8Bit(REG_OP_MODE) & MODE_TX) == MODE_TX) { return 1; } if (readRegLora_8Bit(REG_IRQ_FLAGS) & IRQ_TX_DONE_MASK) { // clear IRQ's writeRegLora(REG_IRQ_FLAGS, IRQ_TX_DONE_MASK); } return 0; } //*********************************************************** //Set imlicit Header Mode void LoraImplicitHeaderMode(void){ writeRegLora(REG_MODEM_CONFIG_1, readRegLora_8Bit(REG_MODEM_CONFIG_1) | 0x01); } //*********************************************************** //Set explicit Header Mode void LoraExplicitHeaderMode(void){ writeRegLora(REG_MODEM_CONFIG_1, readRegLora_8Bit(REG_MODEM_CONFIG_1) & 0xFE); } /********************************************************/ // set Lora into Rx mode : Continous or Single void LoraRxMode(uint8_t RxMode){ writeRegLora(REG_OP_MODE, MODE_LONG_RANGE_MODE | RxMode); } /********************************************************/ // set Lora into Rx mode : Continous or Single void LoraTxMode(){ writeRegLora(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_TX); } /**************************************************************/ void LoraRead(uint8_t *arrayReadData){ uint8_t packetLength = 0; uint8_t i; uint8_t irqFlag = readRegLora_8Bit(REG_IRQ_FLAGS); writeRegLora(REG_IRQ_FLAGS, irqFlag); if((irqFlag & 0x40) != 0){ packetLength = readRegLora_8Bit(REG_RX_NB_BYTES); writeRegLora(REG_FIFO_ADDR_PTR, readRegLora_8Bit(REG_FIFO_RX_CURRENT_ADDR)); for(i = 0; i <packetLength; i++){ arrayReadData[i]=readRegLora_8Bit(REG_FIFO); } //powerReadInt = ( arrayReadData[0]-48)*10 + (arrayReadData[1] -48); //neu doc dc HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_RESET); HAL_Delay(200); HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_SET); HAL_Delay(200); } } /**************************************************************/ //Transfer Data have first address = buffer, and length = uint8_t Size //return Size transfered uint8_t LoraTransfer(uint8_t *buffer, uint8_t size){ // reset FIFO address and paload length writeRegLora(REG_FIFO_ADDR_PTR, 0); writeRegLora(REG_PAYLOAD_LENGTH, 0); writeToFIFO(buffer,size); writeRegLora(REG_PAYLOAD_LENGTH, size); // put in TX mode LoraTxMode(); // wait for TX done while ((readRegLora_8Bit(REG_IRQ_FLAGS) & IRQ_TX_DONE_MASK) == 0) {} // clear IRQ's writeRegLora(REG_IRQ_FLAGS, IRQ_TX_DONE_MASK); return 1; } //convert read data to int

nguyendanghuy247@gmail.com

74155732b9c958f7e75602f9329f9c20146aa7a9

54acb0bc5cfe18341533cf9b451757374e98f9d0

/ProiectRetele/functions.h

95e415efb92f5c944b170864006c8e9debcc06be

no_license

balandan/Proiect-Retele

2a13b6bb3ca917188fa2f41bab159ea47be9ccf2

430503bfc24a963c5577a50a18a3254c3142f217

refs/heads/master

UTF-8

C

h

#include <stdio.h> #include "listOfItems.h" int typeOfUser; int searchInServer(int descriptor,char fileName[30]) { DIR *dir; struct dirent *file; dir = opendir ("."); if(dir==NULL) { printf("Fail to open this directory"); exit(1); } while( (file=readdir(dir))!=NULL ) { if( strcmp(file->d_name,fileName)==0) { closedir(dir); return 1; } } closedir(dir); return 0; } int download(char nameOfFile[30],int descriptor) { int ptr_myfile; int counter=0; char buffer[1024]; char mesaj[100]; bzero(mesaj,100); char messageFromClient[50]; ptr_myfile=open(nameOfFile,O_RDONLY); if (ptr_myfile < 0) { strcat(mesaj,"Unable to open file!"); //printf("%s",mesaj); //write(descriptor,"Unable to open file!",30); } else strcat(mesaj,"The file was found!"); //printf("%d\n",bytes); //printf("%d",counter); printf("[server]%s\n",mesaj); write(descriptor,mesaj,35); bzero(messageFromClient,50); read(descriptor,messageFromClient,50); if(strcmp(messageFromClient,"done")==0 && strcmp(mesaj,"The file was found!")==0) { int bytes; while ((bytes=read(ptr_myfile,buffer,1024))>0) { counter+=bytes; //printf("%d\n",bytes); } int n = counter; write(descriptor, &n, sizeof(n)); close(ptr_myfile); write(descriptor,nameOfFile,100); ptr_myfile=open(nameOfFile,O_RDONLY); while (n>0) { bytes=read(ptr_myfile,buffer,1024); n=n-bytes; printf("[server]We sent %d%s%d%s\n",bytes," there are still ", n ," bytes to send"); sleep(0.1); write(descriptor,buffer,bytes); //printf("[server]We sent %d%s"," bytes"); } } bzero(messageFromClient,50); close(ptr_myfile); } void primireComenzi(int descriptor) { char message[100]; char *firstWord; char *secondWord; char path[100]; read(descriptor,message,100); printf("[server]The message recived:%s",message); //primim comanda //printf("%s",firstWord); if(strcmp(message,"ls\n")==0 && (typeOfUser==0 || typeOfUser==1)) //comanda pentru ls { write(descriptor,"start",6); listOfItems(descriptor); primireComenzi(descriptor); } else if (strcmp(message,"exit\n")==0 && (typeOfUser==0 || typeOfUser==1)) { char answer[5]; write(descriptor,"Are you sure?",15); printf ("[server]Message sent:%s\n","Are you sure?\n"); read(descriptor,answer,5); if(strcmp(answer,"yes")==0) { printf("[server]A client has disconnected\n"); close(descriptor); exit(0); } else primireComenzi(descriptor); } firstWord=strtok(message," "); secondWord=strtok(NULL,"\n"); if(strcmp(firstWord,"download")==0 && (typeOfUser==0 || typeOfUser==1)) { printf("[server]The file that the client ask for:%s\n",secondWord); //read(descriptor,path,100); //printf("%s",path); download(secondWord,descriptor); primireComenzi(descriptor); } else if (strcmp(firstWord,"delete")==0 && typeOfUser==1) { //printf("[server]Message recived:delete %s",secondWord); if(remove(secondWord)==0) write(descriptor,"The file was deleted!",30); else write(descriptor,"The file can't be deleted or do not exist",50); primireComenzi(descriptor); } else if (strcmp(firstWord,"delete")==0 && typeOfUser==0) { primireComenzi(descriptor); } else if (strcmp(firstWord,"copy")==0 && typeOfUser==1) { int x=searchInServer(descriptor,secondWord); if (x==1) { char nameForTheNewFile[30]; char buffer[1024]; char file[30];//numele final al fisierului pe care il deschidem char theFileWeOpen[30]; char *extension;//folosim pentru a afla extensia noului fisier char *nume;//folosim pentru a afla denumirea noului fisier int openFile; write(descriptor,"File found!",15); printf("%s\n","[server]File found!"); read(descriptor,nameForTheNewFile,30); bzero(theFileWeOpen,30); strcat(theFileWeOpen,secondWord); extension=strtok(secondWord,"."); extension=strtok(NULL,"\n"); nume=strtok(nameForTheNewFile,"\n"); bzero(file,30); strcat(file,nume); strcat(file,"."); strcat(file,extension); openFile=open(theFileWeOpen,O_RDONLY); if (openFile < 0) { printf("%s\n","[server]Unable to open file!"); } int x; x=open(file,O_WRONLY|O_CREAT); int bytes=0; while ((bytes=read(openFile,buffer,1024))>0) { write(x,buffer,bytes); } close(x); close(openFile); printf("[server]The file was copied!\n"); write(descriptor,"Done",5); primireComenzi(descriptor); } else { write(descriptor,"File not found!",15); printf("%s\n","[server]File not found!"); primireComenzi(descriptor); } } else if (strcmp(firstWord,"copy")==0 && typeOfUser==0) { primireComenzi(descriptor); } else primireComenzi(descriptor); //primireComenzi(descriptor); } int searchInFile(char user[20],char pass[20]) { int nr_linie=0; int nr_linie2=0; char buffer[20]; FILE *a; a=fopen("user.txt","r"); if (a!=NULL) { while(!feof(a)) { fgets(buffer,20,a); nr_linie+=1; if (strcmp(buffer,user)==0) { break; } bzero(buffer,20); } fclose(a); if(nr_linie %2==1) { a=fopen("user.txt","r"); while(!feof(a)) { fgets(buffer,20,a); nr_linie2+=1; if(nr_linie2==nr_linie+1 && strcmp(buffer,pass)==0) return 1; bzero(buffer,20); } } } return 0; } int typeUser (char username[30]) { char buffer[30]; FILE *b; b=fopen("whitelist.txt","r"); if(b!=NULL) { while(!feof(b)) { fgets(buffer,30,b); if(strcmp(buffer,username)==0) return 1; } } fclose(b); b=fopen("blacklist.txt","r"); if(b!=NULL) { while(!feof(b)) { fgets(buffer,30,b); if(strcmp(buffer,username)==0) return 0; } } fclose(b); } void login (int descriptor) { char *username; char *password; char buffer[100]; char msg[100]; //mesajul primit de la client int i=0; int y; char c; char newPassword[50]; int bytes; bytes = read (descriptor, msg, sizeof (buffer)); //Citim datele de autentificare if (bytes < 0) { perror ("Eroare la read() de la client.\n"); close(descriptor); exit(0); } printf ("[server]Message recived:%s\n", msg); username = strtok(msg,"\n"); //Le prelucram password = strtok(NULL,"\n"); while(password[i]!='\0') { y=(int)password[i]; y--; c=y; newPassword[i]=c; i++; } newPassword[i]='\0'; //Am decriptat parola char spatiu[3]="\n"; char nume[20]; bzero(nume,20); strcat(nume,username); strcat(nume,spatiu); int x=searchInFile(nume,newPassword); //cautam in fisierul de logare daca datele primite sunt valide if(x){ bzero(msg,100); strcat(msg,"Connected"); printf ("[server]Message sent:%s\n",msg); typeOfUser=typeUser(nume); //daca sunt valide determinam din ce fisier face parte userul conectat //printf("%d",typeOfUser); } else { bzero(msg,100); strcat(msg,"Try again"); printf ("[server]Message sent:%s\n",msg); } if (bytes && write (descriptor, msg, bytes) < 0) //trimitem mesaj de raspuns { perror ("[server] Eroare la write() catre client.\n"); //return 0; } if (strcmp(msg,"Connected")==0) //daca mesajul trimis este connected apelam functia unde putem primi comenzi { write(descriptor, &typeOfUser, sizeof(typeOfUser));//scriem clientului tipul de user ce tocmai s-a logat //printf("%d",typeOfUser); primireComenzi(descriptor); } else if(strcmp(msg,"Try again")==0) //daca datele sunt gresite se ofera posibilitatea de a incerca de nou { login(descriptor); } close(descriptor); exit(0); }

noreply@github.com

0a8e0289152e8c5ddde56fb7659d8c479c4582cf

e4a1f59a825748852406246ad4a0a7e58c0c756b

/code/functs.h

be49b077ece743129c59d76e88d82e6b23007194

no_license

MVour/diseaseAggregator

19d46631f1982a407cc243431392c9f1bdc13094

acb9b05c4d6fe73ccbc063f0d4e9132352c9e97d

refs/heads/master

UTF-8

C

h

// #include "myList.h" #include "myHash.h" #include "heap.h" #include "filesStats.h" ////// FUNCTS void printMenu(); char* act(int, hashTable*, hashTable*, infoNode*, StatsList*, char* buf); // void act_1(hashTable*, char*, char*); char* act_2(hashTable*, char*, char*, char*, char*); char* act_3(StatsList* myStats, int, char*, char*, char*, char*); char* act_4(infoNode*, char*); char* act_5(StatsList*, char*, char*, char*, char*); char* act_6(hashTable* , char*, char*, char*, char*); // void act_3_4(hashTable*, char*, char*, char*, int, int); // void act_5(hashTable*, hashTable*, infoNode*, myPatient*); // void act_6(infoNode*, char*, char*); // void act_7(hashTable*, char*); // void act_8(hashTable* cHash, hashTable* dHash, infoNode* pList); int isDate(char*); void treeToHeap(RBT*, maxHeap*, RBnode*, char*, char*, char*); int statsToHeap(StatsList*, maxHeap*, char* country, char* disease, char*, char*); // int count_keys(RBnode* n, char* date1, char* date2);

m.vourtzoumis@gmail.com

25021c56cbd311feb2474cce81be4758cf5ee5d8

394c1965d2300d06df1a72868670397d4ac262c5

/Libft/srcs/ft_putchar_fd.c

df6248e83b11873e2ab6dcb3898dc37e6be95fa4

no_license

lterrail/minishell

f0584386ca9f9184ab21f32ad900610ddb75f090

a2221f74445c526eec356b672efee4640fd7aefb

refs/heads/master

UTF-8

C

c

/* ************************************************************************** */ /* */ /* ::: :::::::: */ /* ft_putchar_fd.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: lterrail <lterrail@student.42.fr> +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2018/04/03 16:24:20 by lterrail #+# #+# */ /* Updated: 2018/04/11 17:00:53 by lterrail ### ########.fr */ /* */ /* ************************************************************************** */ #include "libft.h" void ft_putchar_fd(char c, int fd) { write(fd, &c, 1); }

lterrail@e1r10p17.42.fr

26f23f68c2d65c91dbf7731ee589f62a41d27d8a

7da6ed1e31f4dd92d923cc867f21b33a74e0ebc1

/src/createregion.c

4743ff3cf0a3b2c59883d6f6f024f8bc1946adb9

no_license

freudshow/practice

2f672a460ea9d61135b6ac26919fdd3d9fab5224

6801ea586c5db2f30a268040f3390e303cf0fb89

refs/heads/master

UTF-8

C

c

#include "shm.h" int rand(void); int rand_r(unsigned int *seedp); void srand(unsigned int seed); int main() { init_sem_set(); init_region(); exit(0); }

s_baoshan@163.com

c8bd691314e2dda543aebd10b67df1d55639c9da

598883867c454c3706ef844d5c0505c00142ba61

/LCD/LCD.h

8a928231dcc96aff1080d4fd704910a849aef356

no_license

ahmedelgazwy/Password-Based-Lock

996b245047e1602b175aad5a7b1c04eb3d0e2ff7

337ebc6e545d25e134d972cb5ef637ad986fa650

refs/heads/master

UTF-8

C

h

#ifndef __LCD__H__ #define __LCD__H__ #include "std_types.h" #include "IO_ports.h" #define LCD_DATA GPIO_PORTC_DATA_R #define LCD_DATA_DIR GPIO_PORTC_DIR_R #define LCD_DATA_DEN GPIO_PORTC_DEN_R #define LCD_DATA_AFSEL GPIO_PORTC_AFSEL_R #define LCD_DATA_AMSEL GPIO_PORTC_AMSEL_R #define LCD_DATA_PCTL GPIO_PORTC_PCTL_R #define LCD_CTRL GPIO_PORTD_DATA_R #define LCD_CTRL_DIR GPIO_PORTD_DIR_R #define LCD_CTRL_DEN GPIO_PORTD_DEN_R #define LCD_CTRL_AFSEL GPIO_PORTD_AFSEL_R #define LCD_CTRL_AMSEL GPIO_PORTD_AMSEL_R #define LCD_CTRL_PCTL GPIO_PORTD_PCTL_R #endif

noreply@github.com

04fea91c01ee1587f19ad32ee856fa3859d09f22

ade70089afe2f9bd496985fe67d46c5372042ab0

/nvm/versions/node/v16.14.0/include/node/openssl/opensslv.h

afe0161c9ca2dc78a4eac5c0a5319f30e43aba74

permissive

gn0rt0n/dotfiles

96e37a87cec555cbfd222795466c140eb502c892

35f01242e7ac73a8b21b5e62398f1185102b7ee9

refs/heads/master

C

UTF-8

C

h

/* * Copyright 1999-2021 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the OpenSSL license (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #ifndef HEADER_OPENSSLV_H # define HEADER_OPENSSLV_H #ifdef __cplusplus extern "C" { #endif /*- * Numeric release version identifier: * MNNFFPPS: major minor fix patch status * The status nibble has one of the values 0 for development, 1 to e for betas * 1 to 14, and f for release. The patch level is exactly that. * For example: * 0.9.3-dev 0x00903000 * 0.9.3-beta1 0x00903001 * 0.9.3-beta2-dev 0x00903002 * 0.9.3-beta2 0x00903002 (same as ...beta2-dev) * 0.9.3 0x0090300f * 0.9.3a 0x0090301f * 0.9.4 0x0090400f * 1.2.3z 0x102031af * * For continuity reasons (because 0.9.5 is already out, and is coded * 0x00905100), between 0.9.5 and 0.9.6 the coding of the patch level * part is slightly different, by setting the highest bit. This means * that 0.9.5a looks like this: 0x0090581f. At 0.9.6, we can start * with 0x0090600S... * * (Prior to 0.9.3-dev a different scheme was used: 0.9.2b is 0x0922.) * (Prior to 0.9.5a beta1, a different scheme was used: MMNNFFRBB for * major minor fix final patch/beta) */ # define OPENSSL_VERSION_NUMBER 0x101010dfL # define OPENSSL_VERSION_TEXT "OpenSSL 1.1.1m+quic 14 Dec 2021" /*- * The macros below are to be used for shared library (.so, .dll, ...) * versioning. That kind of versioning works a bit differently between * operating systems. The most usual scheme is to set a major and a minor * number, and have the runtime loader check that the major number is equal * to what it was at application link time, while the minor number has to * be greater or equal to what it was at application link time. With this * scheme, the version number is usually part of the file name, like this: * * libcrypto.so.0.9 * * Some unixen also make a softlink with the major version number only: * * libcrypto.so.0 * * On Tru64 and IRIX 6.x it works a little bit differently. There, the * shared library version is stored in the file, and is actually a series * of versions, separated by colons. The rightmost version present in the * library when linking an application is stored in the application to be * matched at run time. When the application is run, a check is done to * see if the library version stored in the application matches any of the * versions in the version string of the library itself. * This version string can be constructed in any way, depending on what * kind of matching is desired. However, to implement the same scheme as * the one used in the other unixen, all compatible versions, from lowest * to highest, should be part of the string. Consecutive builds would * give the following versions strings: * * 3.0 * 3.0:3.1 * 3.0:3.1:3.2 * 4.0 * 4.0:4.1 * * Notice how version 4 is completely incompatible with version, and * therefore give the breach you can see. * * There may be other schemes as well that I haven't yet discovered. * * So, here's the way it works here: first of all, the library version * number doesn't need at all to match the overall OpenSSL version. * However, it's nice and more understandable if it actually does. * The current library version is stored in the macro SHLIB_VERSION_NUMBER, * which is just a piece of text in the format "M.m.e" (Major, minor, edit). * For the sake of Tru64, IRIX, and any other OS that behaves in similar ways, * we need to keep a history of version numbers, which is done in the * macro SHLIB_VERSION_HISTORY. The numbers are separated by colons and * should only keep the versions that are binary compatible with the current. */ # define SHLIB_VERSION_HISTORY "" # define SHLIB_VERSION_NUMBER "81.1.1" #ifdef __cplusplus } #endif #endif /* HEADER_OPENSSLV_H */

gary@odindev.com

ae6588ae9020907de235f7dc4c83350dbf925003

60cddbbb30ef7614070f6e1691ab9a3f0ce407e4

/robo2-xsdk/libs/phymod/chip/falcon16/falcon16_diagnostics_dispatch.c

12ba0238027635ff729ee0e14f43ab82c3db76e5

no_license

David-Croose/Broadcom-Compute-Connectivity-Software-robo2-xsdk

f2a1fe9a704e1a1873eac2fba02125ba7cb1570f

25b15c851d6e8a5a70715603e4f8d8a9af8f66fe

refs/heads/master

UTF-8

C

c

/* * * $Id: phymod.xml,v 1.1.2.5 Broadcom SDK $ * * * This license is set out in https://github.com/Broadcom/Broadcom-Compute-Connectivity-Software-robo2-xsdk/master/Legal/LICENSE file. * * $Copyright: (c) 2020 Broadcom Inc. * Broadcom Proprietary and Confidential. All rights reserved.$ * * * DO NOT EDIT THIS FILE! * */ #include <phymod/phymod.h> #include <phymod/phymod_diagnostics.h> #include <phymod/phymod_diagnostics_dispatch.h> #ifdef PHYMOD_FALCON16_SUPPORT #include <phymod/chip/falcon16_diagnostics.h> __phymod_diagnostics__dispatch__t__ phymod_diagnostics_falcon16_diagnostics_driver = { falcon16_phy_rx_slicer_position_set, falcon16_phy_rx_slicer_position_get, falcon16_phy_rx_slicer_position_max_get, falcon16_phy_prbs_config_set, falcon16_phy_prbs_config_get, falcon16_phy_prbs_enable_set, falcon16_phy_prbs_enable_get, falcon16_phy_prbs_status_get, falcon16_phy_pattern_config_set, falcon16_phy_pattern_config_get, falcon16_phy_pattern_enable_set, falcon16_phy_pattern_enable_get, falcon16_core_diagnostics_get, falcon16_phy_diagnostics_get, falcon16_phy_pmd_info_dump, NULL, /* phymod_phy_pcs_info_dump */ falcon16_phy_eyescan_run, NULL, /* phymod_phy_link_mon_enable_set */ NULL, /* phymod_phy_link_mon_enable_get */ NULL, /* phymod_phy_link_mon_status_get */ NULL, /* phymod_phy_fec_correctable_counter_get */ NULL, /* phymod_phy_fec_uncorrectable_counter_get */ }; #endif /* PHYMOD_FALCON16_SUPPORT */

murali.policharla@broadcom.com

4e6ed1901fc0f9319647713b68b5b6b327930a06

3f309b1dd9774ca1eef2c7bb7626447e6c3dbe70

/apps/evsys/evsys_trigger/firmware/src/config/sam_l10_xpro/peripheral/clock/plib_clock.c

e3a6e5298e13415f391dd1c25b0e3d7d7fe6eb46

permissive

Unitek-KL/csp

30892ddf1375f5191173cafdfba5f098245a0ff7

2ac7ba59465f23959e51d2f16a5712b57b79ef5f

refs/heads/master

NOASSERTION

UTF-8

C

c

/******************************************************************************* CLOCK PLIB Company: Microchip Technology Inc. File Name: plib_clock.c Summary: CLOCK PLIB Implementation File. Description: None *******************************************************************************/ /******************************************************************************* * Copyright (C) 2018 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. *******************************************************************************/ #include "plib_clock.h" #include "device.h" static void OSCCTRL_Initialize(void) { /**************** OSC16M IniTialization *************/ OSCCTRL_REGS->OSCCTRL_OSC16MCTRL = OSCCTRL_OSC16MCTRL_FSEL(0x0) | OSCCTRL_OSC16MCTRL_ENABLE_Msk; } static void OSC32KCTRL_Initialize(void) { OSC32KCTRL_REGS->OSC32KCTRL_RTCCTRL = OSC32KCTRL_RTCCTRL_RTCSEL(0); } static void FDPLL_Initialize(void) { GCLK_REGS->GCLK_PCHCTRL[0] = GCLK_PCHCTRL_GEN(0x1) | GCLK_PCHCTRL_CHEN_Msk; while ((GCLK_REGS->GCLK_PCHCTRL[0] & GCLK_PCHCTRL_CHEN_Msk) != GCLK_PCHCTRL_CHEN_Msk) { /* Wait for synchronization */ } /****************** DPLL Initialization *********************************/ /* Configure DPLL */ OSCCTRL_REGS->OSCCTRL_DPLLCTRLB = OSCCTRL_DPLLCTRLB_FILTER(0) | OSCCTRL_DPLLCTRLB_LTIME(0)| OSCCTRL_DPLLCTRLB_REFCLK(2) ; OSCCTRL_REGS->OSCCTRL_DPLLRATIO = OSCCTRL_DPLLRATIO_LDRFRAC(0) | OSCCTRL_DPLLRATIO_LDR(63); while((OSCCTRL_REGS->OSCCTRL_DPLLSYNCBUSY & OSCCTRL_DPLLSYNCBUSY_DPLLRATIO_Msk) == OSCCTRL_DPLLSYNCBUSY_DPLLRATIO_Msk) { /* Waiting for the synchronization */ } /* Selection of the DPLL Enable */ OSCCTRL_REGS->OSCCTRL_DPLLCTRLA = OSCCTRL_DPLLCTRLA_ENABLE_Msk ; while((OSCCTRL_REGS->OSCCTRL_DPLLSYNCBUSY & OSCCTRL_DPLLSYNCBUSY_ENABLE_Msk) == OSCCTRL_DPLLSYNCBUSY_ENABLE_Msk ) { /* Waiting for the DPLL enable synchronization */ } while((OSCCTRL_REGS->OSCCTRL_DPLLSTATUS & (OSCCTRL_DPLLSTATUS_LOCK_Msk | OSCCTRL_DPLLSTATUS_CLKRDY_Msk)) != (OSCCTRL_DPLLSTATUS_LOCK_Msk | OSCCTRL_DPLLSTATUS_CLKRDY_Msk)) { /* Waiting for the Ready state */ } } static void GCLK0_Initialize(void) { GCLK_REGS->GCLK_GENCTRL[0] = GCLK_GENCTRL_DIV(2) | GCLK_GENCTRL_SRC(7) | GCLK_GENCTRL_GENEN_Msk; while((GCLK_REGS->GCLK_SYNCBUSY & GCLK_SYNCBUSY_GENCTRL0_Msk) == GCLK_SYNCBUSY_GENCTRL0_Msk) { /* wait for the Generator 0 synchronization */ } } static void GCLK1_Initialize(void) { GCLK_REGS->GCLK_GENCTRL[1] = GCLK_GENCTRL_DIV(4) | GCLK_GENCTRL_SRC(5) | GCLK_GENCTRL_GENEN_Msk; while((GCLK_REGS->GCLK_SYNCBUSY & GCLK_SYNCBUSY_GENCTRL1_Msk) == GCLK_SYNCBUSY_GENCTRL1_Msk) { /* wait for the Generator 1 synchronization */ } } void CLOCK_Initialize (void) { /* Function to Initialize the Oscillators */ OSCCTRL_Initialize(); /* Function to Initialize the 32KHz Oscillators */ OSC32KCTRL_Initialize(); GCLK1_Initialize(); FDPLL_Initialize(); GCLK0_Initialize(); /* Selection of the Generator and write Lock for EIC */ GCLK_REGS->GCLK_PCHCTRL[3] = GCLK_PCHCTRL_GEN(0x0) | GCLK_PCHCTRL_CHEN_Msk; while ((GCLK_REGS->GCLK_PCHCTRL[3] & GCLK_PCHCTRL_CHEN_Msk) != GCLK_PCHCTRL_CHEN_Msk) { /* Wait for synchronization */ } /* Selection of the Generator and write Lock for EVSYS_0 */ GCLK_REGS->GCLK_PCHCTRL[6] = GCLK_PCHCTRL_GEN(0x0) | GCLK_PCHCTRL_CHEN_Msk; while ((GCLK_REGS->GCLK_PCHCTRL[6] & GCLK_PCHCTRL_CHEN_Msk) != GCLK_PCHCTRL_CHEN_Msk) { /* Wait for synchronization */ } }

http://support.microchip.com

140d8434c9645707bed4716235e4ff9dc4315eca

c9eccf85f19371a3843911c1480e761de4773722

/src/lvgl/src/lv_misc/lv_bidi.h

f3f758b43ab14b9f6180db943b44a41d1f39df7d

permissive

mibus/TTGO_TWatch_Library

7d3c04ca2358b181264ea744a1bcd8338f508d91

bd77e6edba3baf9c5c68de4683a01b81f6b3a8b3

refs/heads/master

MIT

UTF-8

C

h

/** * @file lv_bifi.h * */ #ifndef LV_BIDI_H #define LV_BIDI_H #ifdef __cplusplus extern "C" { #endif /********************* * INCLUDES *********************/ #include "../lv_conf_internal.h" #include <stdbool.h> #include <stdint.h> /********************* * DEFINES *********************/ /* Special non printable strong characters. * They can be inserted to texts to affect the run's direction*/ #define LV_BIDI_LRO "\xE2\x80\xAD" /*U+202D*/ #define LV_BIDI_RLO "\xE2\x80\xAE" /*U+202E*/ /********************** * TYPEDEFS **********************/ enum { /*The first 4 values are stored in `lv_obj_t` on 2 bits*/ LV_BIDI_DIR_LTR = 0x00, LV_BIDI_DIR_RTL = 0x01, LV_BIDI_DIR_AUTO = 0x02, LV_BIDI_DIR_INHERIT = 0x03, LV_BIDI_DIR_NEUTRAL = 0x20, LV_BIDI_DIR_WEAK = 0x21, }; typedef uint8_t lv_bidi_dir_t; /********************** * GLOBAL PROTOTYPES **********************/ #if LV_USE_BIDI /** * Convert a text to get the characters in the correct visual order according to * Unicode Bidirectional Algorithm * @param str_in the text to process * @param str_out store the result here. Has the be `strlen(str_in)` length * @param base_dir `LV_BIDI_DIR_LTR` or `LV_BIDI_DIR_RTL` */ void _lv_bidi_process(const char * str_in, char * str_out, lv_bidi_dir_t base_dir); /** * Auto-detect the direction of a text based on the first strong character * @param txt the text to process * @return `LV_BIDI_DIR_LTR` or `LV_BIDI_DIR_RTL` */ lv_bidi_dir_t _lv_bidi_detect_base_dir(const char * txt); /** * Get the logical position of a character in a line * @param str_in the input string. Can be only one line. * @param bidi_txt internally the text is bidi processed which buffer can be get here. * If not required anymore has to freed with `lv_mem_free()` * Can be `NULL` is unused * @param len length of the line in character count * @param base_dir base direction of the text: `LV_BIDI_DIR_LTR` or `LV_BIDI_DIR_RTL` * @param vicual_pos the visual character position which logical position should be get * @param is_rtl tell the the char at `viasual_pos` is RTL or LTR context * @return the logical character position */ uint16_t _lv_bidi_get_logical_pos(const char * str_in, char ** bidi_txt, uint32_t len, lv_bidi_dir_t base_dir, uint32_t visual_pos, bool * is_rtl); /** * Get the visual position of a character in a line * @param str_in the input string. Can be only one line. * @param bidi_txt internally the text is bidi processed which buffer can be get here. * If not required anymore has to freed with `lv_mem_free()` * Can be `NULL` is unused * @param len length of the line in character count * @param base_dir base direction of the text: `LV_BIDI_DIR_LTR` or `LV_BIDI_DIR_RTL` * @param logical_pos the logical character position which visual position should be get * @param is_rtl tell the the char at `logical_pos` is RTL or LTR context * @return the visual character position */ uint16_t _lv_bidi_get_visual_pos(const char * str_in, char ** bidi_txt, uint16_t len, lv_bidi_dir_t base_dir, uint32_t logical_pos, bool * is_rtl); /** * Bidi process a paragraph of text * @param str_in the string to process * @param str_out store the result here * @param len length of teh text * @param base_dir base dir of the text * @param pos_conv_out an `uint16_t` array to store the related logical position of the character. * Can be `NULL` is unused * @param pos_conv_len length of `pos_conv_out` in element count */ void _lv_bidi_process_paragraph(const char * str_in, char * str_out, uint32_t len, lv_bidi_dir_t base_dir, uint16_t * pos_conv_out, uint16_t pos_conv_len); /********************** * MACROS **********************/ #endif /*LV_USE_BIDI*/ #ifdef __cplusplus } /* extern "C" */ #endif #endif /*LV_BIDI_H*/

lewisxhe@outlook.com

0ddad1251dcd4016b4c526efeafe716af3f5026e

ef9a2839953f3586e66c1cf824c9de199f52d088

/mcc_generated_files/X2CCode/Library/Math/Controller/inc/Sqrt_FiP16.h

b83fa9c934f92a6452ef0773f0ae3be8fd299024

no_license

MCHP-X2Cdemos/mc_foc_sl_fip_dsPIC33ck_mclv2.x

72f1e06eb18738796d59938474c6d533bd07bb1e

d77e18983439d895b83b6d63fdaad4c8fdb028e7

refs/heads/master

UTF-8

C

h

/* * Copyright (c) 2013, Linz Center of Mechatronics GmbH (LCM) http://www.lcm.at/ * All rights reserved. */ /* * This file is licensed according to the BSD 3-clause license as follows: * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 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. * * Neither the name of the "Linz Center of Mechatronics GmbH" and "LCM" 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 "Linz Center of Mechatronics GmbH" 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. */ /* * This file is part of X2C. http://x2c.lcm.at/ * $LastChangedRevision: 1603 $ */ /* USERCODE-BEGIN:Description */ /** Description: Square Root Computation **/ /** Calculation: **/ /** y = sqrt((abs(u)) **/ /** **/ /* USERCODE-END:Description */ #ifndef SQRT_FIP16_H #define SQRT_FIP16_H #ifdef __cplusplus extern "C" { #endif #include "CommonFcts.h" #if !defined(SQRT_FIP16_ISLINKED) #define SQRT_FIP16_ID ((uint16)4817) typedef struct { uint16 ID; int16 *In; int16 Out; } SQRT_FIP16; #define SQRT_FIP16_FUNCTIONS { \ SQRT_FIP16_ID, \ (void (*)(void*))Sqrt_FiP16_Update, \ (void (*)(void*))Sqrt_FiP16_Init, \ (tLoadImplementationParameter)Common_Load, \ (tSaveImplementationParameter)Common_Save, \ (void* (*)(const void*, uint16))Sqrt_FiP16_GetAddress } /**********************************************************************************************************************/ /** Public prototypes **/ /**********************************************************************************************************************/ void Sqrt_FiP16_Update(SQRT_FIP16 *pTSqrt_FiP16); void Sqrt_FiP16_Init(SQRT_FIP16 *pTSqrt_FiP16); void* Sqrt_FiP16_GetAddress(const SQRT_FIP16 *block, uint16 elementId); #endif #ifdef __cplusplus } #endif #endif

christoph.baumgartner@microchipcom

00b89f8c82ebde7fba9cca6124b9592cc534c8af

a0d6b2c2dd8bcbe03e5c6fb35f766bd2af9a1d5c

/dynix.3.2.0/src/ucb/tftp/main.c

a7f804e9f48afbb7a6089aad2297032b45976d5f

no_license

legacy-codedigger/Dynix.3.2.Source

593485f234eee4de75c0e23fe689f247471c83f8

2789373c94bc57e4c4a915bcba354f2243e12ca4

refs/heads/master

UTF-8

C

c

/* $Copyright: $ * Copyright (c) 1984, 1985, 1986, 1987, 1988, 1989, 1990 * Sequent Computer Systems, Inc. All rights reserved. * * This software is furnished under a license and may be used * only in accordance with the terms of that license and with the * inclusion of the above copyright notice. This software may not * be provided or otherwise made available to, or used by, any * other person. No title to or ownership of the software is * hereby transferred. */ #ifndef lint static char rcsid[] = "$Header: main.c 2.3 90/04/05 $"; #endif /* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms are permitted * provided that the above copyright notice and this paragraph are * duplicated in all such forms and that any documentation, * advertising materials, and other materials related to such * distribution and use acknowledge that the software was developed * by the University of California, Berkeley. The name of the * University may not be used to endorse or promote products derived * from this software without specific prior written permission. * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef lint char copyright[] = "@(#) Copyright (c) 1983 Regents of the University of California.\n\ All rights reserved.\n"; #endif /* not lint */ #ifndef lint static char sccsid[] = "@(#)main.c 5.7 (Berkeley) 6/29/88"; #endif /* not lint */ /* Many bug fixes are from Jim Guyton <guyton@rand-unix> */ /* * TFTP User Program -- Command Interface. */ #include <sys/types.h> #include <sys/socket.h> #include <sys/file.h> #include <netinet/in.h> #include <signal.h> #include <stdio.h> #include <errno.h> #include <setjmp.h> #include <ctype.h> #include <netdb.h> #define TIMEOUT 5 /* secs between rexmt's */ struct sockaddr_in sin; int f; short port; int trace; int verbose; int connected; char mode[32]; char line[200]; int margc; char *margv[20]; char *prompt = "tftp"; jmp_buf toplevel; int intr(); struct servent *sp; int quit(), help(), setverbose(), settrace(), status(); int get(), put(), setpeer(), modecmd(), setrexmt(), settimeout(); int setbinary(), setascii(); #define HELPINDENT (sizeof("connect")) struct cmd { char *name; char *help; int (*handler)(); }; char vhelp[] = "toggle verbose mode"; char thelp[] = "toggle packet tracing"; char chelp[] = "connect to remote tftp"; char qhelp[] = "exit tftp"; char hhelp[] = "print help information"; char shelp[] = "send file"; char rhelp[] = "receive file"; char mhelp[] = "set file transfer mode"; char sthelp[] = "show current status"; char xhelp[] = "set per-packet retransmission timeout"; char ihelp[] = "set total retransmission timeout"; char ashelp[] = "set mode to netascii"; char bnhelp[] = "set mode to octet"; struct cmd cmdtab[] = { { "connect", chelp, setpeer }, { "mode", mhelp, modecmd }, { "put", shelp, put }, { "get", rhelp, get }, { "quit", qhelp, quit }, { "verbose", vhelp, setverbose }, { "trace", thelp, settrace }, { "status", sthelp, status }, { "binary", bnhelp, setbinary }, { "ascii", ashelp, setascii }, { "rexmt", xhelp, setrexmt }, { "timeout", ihelp, settimeout }, { "?", hhelp, help }, 0 }; struct cmd *getcmd(); char *tail(); char *index(); char *rindex(); main(argc, argv) char *argv[]; { struct sockaddr_in sin; int top; sp = getservbyname("tftp", "udp"); if (sp == 0) { fprintf(stderr, "tftp: udp/tftp: unknown service\n"); exit(1); } f = socket(AF_INET, SOCK_DGRAM, 0); if (f < 0) { perror("tftp: socket"); exit(3); } bzero((char *)&sin, sizeof (sin)); sin.sin_family = AF_INET; if (bind(f, &sin, sizeof (sin)) < 0) { perror("tftp: bind"); exit(1); } strcpy(mode, "netascii"); signal(SIGINT, intr); if (argc > 1) { if (setjmp(toplevel) != 0) exit(0); setpeer(argc, argv); } top = setjmp(toplevel) == 0; for (;;) command(top); } char hostname[100]; setpeer(argc, argv) int argc; char *argv[]; { struct hostent *host; if (argc < 2) { strcpy(line, "Connect "); printf("(to) "); gets(&line[strlen(line)]); makeargv(); argc = margc; argv = margv; } if (argc > 3) { printf("usage: %s host-name [port]\n", argv[0]); return; } host = gethostbyname(argv[1]); if (host) { sin.sin_family = host->h_addrtype; bcopy(host->h_addr, &sin.sin_addr, host->h_length); strcpy(hostname, host->h_name); } else { sin.sin_family = AF_INET; sin.sin_addr.s_addr = inet_addr(argv[1]); if (sin.sin_addr.s_addr == -1) { connected = 0; printf("%s: unknown host\n", argv[1]); return; } strcpy(hostname, argv[1]); } port = sp->s_port; if (argc == 3) { port = atoi(argv[2]); if (port < 0) { printf("%s: bad port number\n", argv[2]); connected = 0; return; } port = htons(port); } connected = 1; } struct modes { char *m_name; char *m_mode; } modes[] = { { "ascii", "netascii" }, { "netascii", "netascii" }, { "binary", "octet" }, { "image", "octet" }, { "octet", "octet" }, /* { "mail", "mail" }, */ { 0, 0 } }; modecmd(argc, argv) char *argv[]; { register struct modes *p; char *sep; if (argc < 2) { printf("Using %s mode to transfer files.\n", mode); return; } if (argc == 2) { for (p = modes; p->m_name; p++) if (strcmp(argv[1], p->m_name) == 0) break; if (p->m_name) { setmode(p->m_mode); return; } printf("%s: unknown mode\n", argv[1]); /* drop through and print usage message */ } printf("usage: %s [", argv[0]); sep = " "; for (p = modes; p->m_name; p++) { printf("%s%s", sep, p->m_name); if (*sep == ' ') sep = " | "; } printf(" ]\n"); return; } setbinary(argc, argv) char *argv[]; { setmode("octet"); } setascii(argc, argv) char *argv[]; { setmode("netascii"); } setmode(newmode) char *newmode; { strcpy(mode, newmode); if (verbose) printf("mode set to %s\n", mode); } /* * Send file(s). */ put(argc, argv) char *argv[]; { int fd; register int n; register char *cp, *targ; if (argc < 2) { strcpy(line, "send "); printf("(file) "); gets(&line[strlen(line)]); makeargv(); argc = margc; argv = margv; } if (argc < 2) { putusage(argv[0]); return; } targ = argv[argc - 1]; if (index(argv[argc - 1], ':')) { char *cp; struct hostent *hp; for (n = 1; n < argc - 1; n++) if (index(argv[n], ':')) { putusage(argv[0]); return; } cp = argv[argc - 1]; targ = index(cp, ':'); *targ++ = 0; hp = gethostbyname(cp); if (hp == 0) { printf("%s: Unknown host.\n", cp); return; } bcopy(hp->h_addr, (caddr_t)&sin.sin_addr, hp->h_length); sin.sin_family = hp->h_addrtype; connected = 1; strcpy(hostname, hp->h_name); port = sp->s_port; } if (!connected) { printf("No target machine specified.\n"); return; } if (argc < 4) { cp = argc == 2 ? tail(targ) : argv[1]; fd = open(cp, O_RDONLY); if (fd < 0) { fprintf(stderr, "tftp: "); perror(cp); return; } if (verbose) printf("putting %s to %s:%s [%s]\n", cp, hostname, targ, mode); sin.sin_port = port; sendfile(fd, targ, mode); return; } /* this assumes the target is a directory */ /* on a remote unix system. hmmmm. */ cp = index(targ, '\0'); *cp++ = '/'; for (n = 1; n < argc - 1; n++) { strcpy(cp, tail(argv[n])); fd = open(argv[n], O_RDONLY); if (fd < 0) { fprintf(stderr, "tftp: "); perror(argv[n]); continue; } if (verbose) printf("putting %s to %s:%s [%s]\n", argv[n], hostname, targ, mode); sin.sin_port = port; sendfile(fd, targ, mode); } } putusage(s) char *s; { printf("usage: %s file ... host:target, or\n", s); printf(" %s file ... target (when already connected)\n", s); } /* * Receive file(s). */ get(argc, argv) char *argv[]; { int fd; register int n; register char *cp; char *src; if (argc < 2) { strcpy(line, "get "); printf("(files) "); gets(&line[strlen(line)]); makeargv(); argc = margc; argv = margv; } if (argc < 2) { getusage(argv[0]); return; } if (!connected) { for (n = 1; n < (argc - 1); n++) if (index(argv[n], ':') == 0) { getusage(argv[0]); return; } } for (n = 1; n < argc ; n++) { src = index(argv[n], ':'); if (src == NULL) src = argv[n]; else { struct hostent *hp; *src++ = 0; hp = gethostbyname(argv[n]); if (hp == 0) { printf("%s: Unknown host.\n", argv[n]); continue; } bcopy(hp->h_addr, (caddr_t)&sin.sin_addr, hp->h_length); sin.sin_family = hp->h_addrtype; connected = 1; strcpy(hostname, hp->h_name); port = sp->s_port; } if (argc < 4) { cp = argc == 3 ? argv[2] : tail(src); fd = creat(cp, 0644); if (fd < 0) { fprintf(stderr, "tftp: "); perror(cp); return; } if (verbose) printf("getting from %s:%s to %s [%s]\n", hostname, src, cp, mode); sin.sin_port = port; recvfile(fd, src, mode); break; } cp = tail(src); /* new .. jdg */ fd = creat(cp, 0644); if (fd < 0) { fprintf(stderr, "tftp: "); perror(cp); continue; } if (verbose) printf("getting from %s:%s to %s [%s]\n", hostname, src, cp, mode); sin.sin_port = port; recvfile(fd, src, mode); } } getusage(s) char * s; { printf("usage: %s host:file host:file ... file, or\n", s); printf(" %s file file ... file if connected\n", s); } int rexmtval = TIMEOUT; setrexmt(argc, argv) char *argv[]; { int t; if (argc < 2) { strcpy(line, "Rexmt-timeout "); printf("(value) "); gets(&line[strlen(line)]); makeargv(); argc = margc; argv = margv; } if (argc != 2) { printf("usage: %s value\n", argv[0]); return; } t = atoi(argv[1]); if (t < 0) printf("%s: bad value\n", t); else rexmtval = t; } int maxtimeout = 5 * TIMEOUT; settimeout(argc, argv) char *argv[]; { int t; if (argc < 2) { strcpy(line, "Maximum-timeout "); printf("(value) "); gets(&line[strlen(line)]); makeargv(); argc = margc; argv = margv; } if (argc != 2) { printf("usage: %s value\n", argv[0]); return; } t = atoi(argv[1]); if (t < 0) printf("%s: bad value\n", t); else maxtimeout = t; } status(argc, argv) char *argv[]; { if (connected) printf("Connected to %s.\n", hostname); else printf("Not connected.\n"); printf("Mode: %s Verbose: %s Tracing: %s\n", mode, verbose ? "on" : "off", trace ? "on" : "off"); printf("Rexmt-interval: %d seconds, Max-timeout: %d seconds\n", rexmtval, maxtimeout); } intr() { signal(SIGALRM, SIG_IGN); alarm(0); longjmp(toplevel, -1); } char * tail(filename) char *filename; { register char *s; while (*filename) { s = rindex(filename, '/'); if (s == NULL) break; if (s[1]) return (s + 1); *s = '\0'; } return (filename); } /* * Command parser. */ command(top) int top; { register struct cmd *c; if (!top) putchar('\n'); for (;;) { printf("%s> ", prompt); if (gets(line) == 0) { if (feof(stdin)) { quit(); } else { continue; } } if (line[0] == 0) continue; makeargv(); c = getcmd(margv[0]); if (c == (struct cmd *)-1) { printf("?Ambiguous command\n"); continue; } if (c == 0) { printf("?Invalid command\n"); continue; } (*c->handler)(margc, margv); } } struct cmd * getcmd(name) register char *name; { register char *p, *q; register struct cmd *c, *found; register int nmatches, longest; longest = 0; nmatches = 0; found = 0; for (c = cmdtab; p = c->name; c++) { for (q = name; *q == *p++; q++) if (*q == 0) /* exact match? */ return (c); if (!*q) { /* the name was a prefix */ if (q - name > longest) { longest = q - name; nmatches = 1; found = c; } else if (q - name == longest) nmatches++; } } if (nmatches > 1) return ((struct cmd *)-1); return (found); } /* * Slice a string up into argc/argv. */ makeargv() { register char *cp; register char **argp = margv; margc = 0; for (cp = line; *cp;) { while (isspace(*cp)) cp++; if (*cp == '\0') break; *argp++ = cp; margc += 1; while (*cp != '\0' && !isspace(*cp)) cp++; if (*cp == '\0') break; *cp++ = '\0'; } *argp++ = 0; } /*VARARGS*/ quit() { exit(0); } /* * Help command. */ help(argc, argv) int argc; char *argv[]; { register struct cmd *c; if (argc == 1) { printf("Commands may be abbreviated. Commands are:\n\n"); for (c = cmdtab; c->name; c++) printf("%-*s\t%s\n", HELPINDENT, c->name, c->help); return; } while (--argc > 0) { register char *arg; arg = *++argv; c = getcmd(arg); if (c == (struct cmd *)-1) printf("?Ambiguous help command %s\n", arg); else if (c == (struct cmd *)0) printf("?Invalid help command %s\n", arg); else printf("%s\n", c->help); } } /*VARARGS*/ settrace() { trace = !trace; printf("Packet tracing %s.\n", trace ? "on" : "off"); } /*VARARGS*/ setverbose() { verbose = !verbose; printf("Verbose mode %s.\n", verbose ? "on" : "off"); }

zahir.meddour@protonmail.com

32004cd6aee41c08905cd5b705ab6f8ff0bb6507

cdf75036c20eed12b54f9110c95588652899fa4c

/Others/atoi_2.c

1845ab7cbe713cde67484b57a0fe4dd8bbf74bd5

no_license

M1c17/C_Programming_Language

6ca585297ab6014a8a5a86ec1e4be8fb58f01e39

15c3074a7876dea9615a3d4a5dd0bb8120abf180

refs/heads/main

UTF-8

C

c

#include <stdio.h> #include <ctype.h> #include <string.h> /* atoi: convert s to integer; version 2 */ int atoi(char line[]); int main(){ int val; char str[10]; strcpy(str, "-93284927"); val = atoi(str); printf("String value = %s, Int value = %d\n", str, val); strcpy(str, "hello"); val = atoi(str); printf("String value = %s, Int value = %d\n", str, val); return 0; } int atoi(char line[]){ //Initialize variables int i, n, sign; //skip white space, if any for (i = 0; isspace(line[i]); ++i){ ; } //get sign, if any sign = (line[i] == '-') ? -1 : 1; //skip sign, if any if (line[i] == '+' || line[i] == '-'){ ++i; } //get integer part and convert it for (n = 0; isdigit(line[i]); ++i){ n = 10 * n + (line[i] - '0'); } return sign * n; }

pictor117@gmail.com

f8a07ef6a3923daba641e7ac3c0fd7ad2ecbfc87

1fabbdfd1ca9ea1b6808893e12bd907eb74de414

/xcode/Classes/Native/AssemblyU2DCSharp_SPacket_SocketInstance_GC_SYNC_REACHEDSCENMethodDeclarations.h

cc71e70250fd75fada95620a65e6af4003c60645

no_license

Klanly/TutorialPackageClient

6f889e96c40ab13c97d107708ae8f3c71a484301

b9d61ba2f287c491c9565b432f852980ec3fee28

refs/heads/master

UTF-8

C

h

#pragma once #include <stdint.h> #include <assert.h> #include <exception> #include "codegen/il2cpp-codegen.h" // SPacket.SocketInstance.GC_SYNC_REACHEDSCENEHandler struct GC_SYNC_REACHEDSCENEHandler_t2847; // PacketDistributed struct PacketDistributed_t2209; // System.Void SPacket.SocketInstance.GC_SYNC_REACHEDSCENEHandler::.ctor() void GC_SYNC_REACHEDSCENEHandler__ctor_m16033 (GC_SYNC_REACHEDSCENEHandler_t2847 * __this, MethodInfo* method) IL2CPP_METHOD_ATTR; // System.UInt32 SPacket.SocketInstance.GC_SYNC_REACHEDSCENEHandler::Execute(PacketDistributed) uint32_t GC_SYNC_REACHEDSCENEHandler_Execute_m16034 (GC_SYNC_REACHEDSCENEHandler_t2847 * __this, PacketDistributed_t2209 * ___ipacket, MethodInfo* method) IL2CPP_METHOD_ATTR;

bu213200@gmail.com

7474d91708e166196a92071abed55e4358790a6c

33a6448e047d43eeeebe36f11cec5863c4d237c9

/FileReadWriteCharacter/main.c

f73b56c824db77ca9043f16bbc2c6f2800163b97

no_license

Qianfinland/C

fca683f4e503a63435f43d1c82d1b5704b954bcf

00f6530d1282149b5d218e4ab4069562c145fd8e

refs/heads/master

UTF-8

C

c

#include <stdio.h> int main() { FILE *file = fopen("/home/qxzhou/NetBeansProjects/daydaylearning/FileReadWriteCharacter/read.txt", "r"); if(file == NULL) { printf("Error on open the file !"); return 1; } while(1) { int ch = fgetc(file); if(ch == EOF) break; printf("%c", ch); } FILE *file2 = fopen("/home/qxzhou/NetBeansProjects/daydaylearning/FileReadWriteCharacter/write.txt", "w"); if(file2 == NULL) { printf("Error on open the file !"); return 1; } /*char c[1000]; printf("Enter a sentence to the file!\n"); fgets(c, sizeof(c), stdin); //gets(c);//dangerous to use fprintf(file2, "%s", c);*/ printf("Enter multiple lines of strings and end by ctrl+D\n"); while(1) { char ch; ch = getchar(); //putchar(ch);// if(ch == EOF) break; putc(ch, file2); } fclose(file); fclose(file2); return 0; }

qianfinland@gmail.com

726a722b8c6dcb1d128fb29aeec5b4130d327071

999d0cc68f04af3168b1eb5f766756b5661170f4

/robot/第四组/舵机-STM32/USER/main.c

555d4c36330cc649455c80a1336c946a2637e724

no_license

aestheticisma/2019

e89e24b6fdf5e56d76af3211b97194ea01bab0e1

4286782e714cdcda86f8c477be2fc5a9297f49aa

refs/heads/master

GB18030

C

c

#include "stm32f10x.h" #include "car.h" #include "delay.h" #include "control.h" #include "echo.h" #include "infrared.h" int main(void) { float a=0.0; char len; control_init(); SysTick_Init();//延时初始化 echo_init(); infrared_init(); //Usart1_Init(); while(1) { len='0'; a=(((float)Get_Adc(ADC_Channel_1))/4096)*3.3; if(a>=0.95){ len = '1'; } USART_SendData(USART1,len); while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET); static_pole(); Delay_ms(2000); } } //每次timer之后 void TIM3_IRQHandler(void) { if(TIM_GetITStatus(TIM3,TIM_IT_Update) != RESET) { TIM_ClearITPendingBit(TIM3, TIM_IT_Update); } } void USART1_IRQHandler(void) { int order= 0 ; if(USART_GetITStatus(USART1,USART_IT_RXNE)==SET) { order = USART_ReceiveData(USART1); USART_ClearITPendingBit(USART1,USART_IT_RXNE); USART_ClearFlag(USART1,USART_IT_RXNE); switch(order) { case 0x00000031://前进 up(); break; case 0x00000032://倒车 down(); break; } } }

noreply@github.com

e68b09ef487cfbc95b0472becf08661d8f918a67

93f2b5dc75142b5d6f5cb31e1e02f1c5aac130a0

/srcs_lem/get_next_line1.c

9a771719bb18a1137c4edc964beaab2d64290170

no_license

Enshertid/lem-in_school21

d869541fb45c6c6f9d8f96bb047d489aed895b26

3b326ec0c41cefe4af28eb46d76817ad89612a33

refs/heads/master

UTF-8

C

c

/* ************************************************************************** */ /* */ /* ::: :::::::: */ /* get_next_line1.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: ymanilow <ymanilow@student.42.fr> +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2019/10/02 14:42:04 by dbendu #+# #+# */ /* Updated: 2020/02/13 21:25:11 by ymanilow ### ########.fr */ /* */ /* ************************************************************************** */ #include "lem_in.h" #define GNL_BUFF 1024 void ft_lstappend(t_list **list, t_list *new) { if (!list || !new) return ; if (!*list) { *list = new; new->end = new; } else { (*list)->end->next = new; (*list)->end = new; } } static void add_in_bufs(t_list **bufs, const char *src, size_t strlen, int fd) { char *str; str = ft_strnew(strlen); ft_memcpy(str, src, strlen); ft_lstappend(bufs, ft_lstnew(str, strlen + 1)); (*bufs)->end->content_size = fd; free(str); } static int check_bufs(t_list **bufs, t_list **buf, int fd) { t_list *iter; char *npos; char *temp; iter = *bufs; while (iter && (int)iter->content_size != fd) iter = iter->next; if (!iter) return (0); npos = (char*)ft_memchr(iter->content, '\n', ft_strlen(iter->content)); ft_lstappend(buf, ft_lstnew(iter->content, npos ? (size_t)(npos - (char*)iter->content) : (size_t)ft_strlen(iter->content))); if (!npos || (npos && !npos[1])) ft_lstdelete(bufs, &iter); else if (npos[1]) { temp = ft_strdup(npos + 1); free(iter->content); iter->content = temp; } return (npos ? 1 : 0); } static char *lst_to_str(const t_list *list) { char *str; char *striter; const t_list *lstiter; size_t len; len = 0; lstiter = list; while (lstiter) { len += lstiter->content_size; lstiter = lstiter->next; } str = ft_strnew(len); if (!str) return (NULL); striter = str; while (list) { ft_memcpy(striter, list->content, list->content_size); striter += list->content_size; list = list->next; } return (str); } int get_next_line(const int fd, char **line) { static t_list *bufs = NULL; t_list *buf; ssize_t ret; char *npos; char str[GNL_BUFF]; if (fd < 0 || !GNL_BUFF || read(fd, str, 0) < 0 || (buf = NULL)) return (-1); if (!check_bufs(&bufs, &buf, fd)) { while ((ret = read(fd, str, GNL_BUFF))) { npos = (char*)ft_memchr(str, '\n', ret); ft_lstappend(&buf, ft_lstnew(str, npos ? npos - str : ret)); if (npos) break ; } if (!ret && !buf) return (0); if (ret && npos && npos - str != ret - 1) add_in_bufs(&bufs, npos + 1, ret - 1 - (npos - str), fd); } *line = lst_to_str(buf); ft_lstpurge(&buf); return (*line ? 1 : -1); }

enshertid@icloud.com

26393171c0093670884c0ea4829ff4beaea2848e

fda015cc078e877754e4cd5a48e970f0a1159ada

/src/sources/shared/system_support/os_specifics.h

aee560f47e775860f7a101ac20eaaa04456aeddf

no_license

cran/liquidSVM

886e0487104a434d3854120a774ebe120e1ddeae

35b8af219f5d52df5513789793c1e5cf07d310b8

refs/heads/master

UTF-8

C

h

// Copyright 2015, 2016, 2017 Ingo Steinwart // // This file is part of liquidSVM. // // liquidSVM is free software: you can redistribute it and/or modify // it under the terms of the GNU Affero General Public License as // published by the Free Software Foundation, either version 3 of the // License, or (at your option) any later version. // // liquidSVM 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 Affero General Public License for more details. // You should have received a copy of the GNU Affero General Public License // along with liquidSVM. If not, see <http://www.gnu.org/licenses/>. #if !defined (OS_SPECIFICS_H) #define OS_SPECIFICS_H #include "sources/shared/system_support/compiler_specifics.h" //********************************************************************************************************************************** // Linux and Mac //********************************************************************************************************************************** #if defined __linux__ || defined __MACH__ #define POSIX_OS__ #define THREADING_IMPLEMENTED #ifdef __SSE2__ #define SSE2__ #endif #ifdef __AVX__ #define AVX__ #endif #ifdef __AVX2__ #define AVX2__ #endif #define sync_add_and_fetch __sync_add_and_fetch #define Tmutex pthread_mutex_t #define Tthread_handle pthread_t #define atomic_unsigned unsigned #define thread__ __thread #define restrict__ __restrict__ #endif //********************************************************************************************************************************** // Windows //********************************************************************************************************************************** #if defined _WIN32 #if !defined (NOMINMAX) #define NOMINMAX #endif #include <malloc.h> // Has to come before windows.h #include <windows.h> // Has to come before emmintrin.h/immintrin.h in simd_basics.h ! #include <iso646.h> #define THREADING_IMPLEMENTED #undef COMPILE_WITH_CUDA__ // The next line repeats the default of MS Visual Studio 2012++ // Basically, it assumes that Windows is not running on a CPU built before 2004 or so. #define SSE2__ #ifdef __AVX__ #define AVX__ #endif #ifdef __AVX2__ #define AVX2__ #endif #define Tmutex HANDLE #define Tthread_handle HANDLE #ifdef __MINGW32__ #define sync_add_and_fetch __sync_add_and_fetch #define atomic_unsigned unsigned #define thread__ __thread #else #define sync_add_and_fetch atomic_fetch_add #if defined(MSVISUAL_LEGACY) #define atomic_unsigned unsigned #else #define atomic_unsigned atomic_uint #endif #define thread__ __declspec(thread) #endif #define restrict__ __restrict #endif //********************************************************************************************************************************** // Other Operating Systems //********************************************************************************************************************************** #if !defined(POSIX_OS__) && !defined(_WIN32) #define UNKNOWN_OS__ #undef THREADING_IMPLEMENTED // The following definitions are meant as safeguards. Depending on the // situtation they may or may not be necessary. #undef SSE2__ #undef AVX__ #undef AVX2__ #undef COMPILE_WITH_CUDA__ #define Tmutex unsigned #define Tthread_handle void* #define atomic_unsigned unsigned #define thread__ #define restrict__ #endif //********************************************************************************************************************************** // More safeguards //********************************************************************************************************************************** // Make sure that simd instructions are only used on systems on which we can // safely alloc aligned memory. Currently, this is true for MS Windows and // systems supporting POSIX with optional posix_memalign commands. #if defined _WIN32 #define SIMD_ACTIVATED #else #include <unistd.h> #if defined(_POSIX_ADVISORY_INFO) && _POSIX_ADVISORY_INFO > 0 #define SIMD_ACTIVATED #else #undef SIMD_ACTIVATED #undef AVX2__ #undef AVX__ #undef SSE2__ #endif #endif #endif

csardi.gabor+cran@gmail.com

85535a4d92f8f2666b9a5170975b7e8728e2f10d

bd1fea86d862456a2ec9f56d57f8948456d55ee6

/000/246/087/CWE78_OS_Command_Injection__char_listen_socket_w32_execv_13.c

820a233fd4b7e26bdeed91be32983bf04da283ab

no_license

CU-0xff/juliet-cpp

d62b8485104d8a9160f29213368324c946f38274

d8586a217bc94cbcfeeec5d39b12d02e9c6045a2

refs/heads/master

UTF-8

C

c

/* TEMPLATE GENERATED TESTCASE FILE Filename: CWE78_OS_Command_Injection__char_listen_socket_w32_execv_13.c Label Definition File: CWE78_OS_Command_Injection.strings.label.xml Template File: sources-sink-13.tmpl.c */ /* * @description * CWE: 78 OS Command Injection * BadSource: listen_socket Read data using a listen socket (server side) * GoodSource: Fixed string * Sink: w32_execv * BadSink : execute command with execv * Flow Variant: 13 Control flow: if(GLOBAL_CONST_FIVE==5) and if(GLOBAL_CONST_FIVE!=5) * * */ #include "std_testcase.h" #include <wchar.h> #ifdef _WIN32 #define COMMAND_INT_PATH "%WINDIR%\\system32\\cmd.exe" #define COMMAND_INT "cmd.exe" #define COMMAND_ARG1 "/c" #define COMMAND_ARG2 "dir " #define COMMAND_ARG3 data #else /* NOT _WIN32 */ #include <unistd.h> #define COMMAND_INT_PATH "/bin/sh" #define COMMAND_INT "sh" #define COMMAND_ARG1 "-c" #define COMMAND_ARG2 "ls " #define COMMAND_ARG3 data #endif #ifdef _WIN32 #include <winsock2.h> #include <windows.h> #include <direct.h> #pragma comment(lib, "ws2_32") /* include ws2_32.lib when linking */ #define CLOSE_SOCKET closesocket #else #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #define INVALID_SOCKET -1 #define SOCKET_ERROR -1 #define CLOSE_SOCKET close #define SOCKET int #endif #define TCP_PORT 27015 #define LISTEN_BACKLOG 5 #include <process.h> #define EXECV _execv #ifndef OMITBAD void CWE78_OS_Command_Injection__char_listen_socket_w32_execv_13_bad() { char * data; char dataBuffer[100] = COMMAND_ARG2; data = dataBuffer; if(GLOBAL_CONST_FIVE==5) { { #ifdef _WIN32 WSADATA wsaData; int wsaDataInit = 0; #endif int recvResult; struct sockaddr_in service; char *replace; SOCKET listenSocket = INVALID_SOCKET; SOCKET acceptSocket = INVALID_SOCKET; size_t dataLen = strlen(data); do { #ifdef _WIN32 if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR) { break; } wsaDataInit = 1; #endif /* POTENTIAL FLAW: Read data using a listen socket */ listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (listenSocket == INVALID_SOCKET) { break; } memset(&service, 0, sizeof(service)); service.sin_family = AF_INET; service.sin_addr.s_addr = INADDR_ANY; service.sin_port = htons(TCP_PORT); if (bind(listenSocket, (struct sockaddr*)&service, sizeof(service)) == SOCKET_ERROR) { break; } if (listen(listenSocket, LISTEN_BACKLOG) == SOCKET_ERROR) { break; } acceptSocket = accept(listenSocket, NULL, NULL); if (acceptSocket == SOCKET_ERROR) { break; } /* Abort on error or the connection was closed */ recvResult = recv(acceptSocket, (char *)(data + dataLen), sizeof(char) * (100 - dataLen - 1), 0); if (recvResult == SOCKET_ERROR || recvResult == 0) { break; } /* Append null terminator */ data[dataLen + recvResult / sizeof(char)] = '\0'; /* Eliminate CRLF */ replace = strchr(data, '\r'); if (replace) { *replace = '\0'; } replace = strchr(data, '\n'); if (replace) { *replace = '\0'; } } while (0); if (listenSocket != INVALID_SOCKET) { CLOSE_SOCKET(listenSocket); } if (acceptSocket != INVALID_SOCKET) { CLOSE_SOCKET(acceptSocket); } #ifdef _WIN32 if (wsaDataInit) { WSACleanup(); } #endif } } { char *args[] = {COMMAND_INT_PATH, COMMAND_ARG1, COMMAND_ARG3, NULL}; /* execv - specify the path where the command is located */ /* POTENTIAL FLAW: Execute command without validating input possibly leading to command injection */ EXECV(COMMAND_INT_PATH, args); } } #endif /* OMITBAD */ #ifndef OMITGOOD /* goodG2B1() - use goodsource and badsink by changing the GLOBAL_CONST_FIVE==5 to GLOBAL_CONST_FIVE!=5 */ static void goodG2B1() { char * data; char dataBuffer[100] = COMMAND_ARG2; data = dataBuffer; if(GLOBAL_CONST_FIVE!=5) { /* INCIDENTAL: CWE 561 Dead Code, the code below will never run */ printLine("Benign, fixed string"); } else { /* FIX: Append a fixed string to data (not user / external input) */ strcat(data, "*.*"); } { char *args[] = {COMMAND_INT_PATH, COMMAND_ARG1, COMMAND_ARG3, NULL}; /* execv - specify the path where the command is located */ /* POTENTIAL FLAW: Execute command without validating input possibly leading to command injection */ EXECV(COMMAND_INT_PATH, args); } } /* goodG2B2() - use goodsource and badsink by reversing the blocks in the if statement */ static void goodG2B2() { char * data; char dataBuffer[100] = COMMAND_ARG2; data = dataBuffer; if(GLOBAL_CONST_FIVE==5) { /* FIX: Append a fixed string to data (not user / external input) */ strcat(data, "*.*"); } { char *args[] = {COMMAND_INT_PATH, COMMAND_ARG1, COMMAND_ARG3, NULL}; /* execv - specify the path where the command is located */ /* POTENTIAL FLAW: Execute command without validating input possibly leading to command injection */ EXECV(COMMAND_INT_PATH, args); } } void CWE78_OS_Command_Injection__char_listen_socket_w32_execv_13_good() { goodG2B1(); goodG2B2(); } #endif /* OMITGOOD */ /* Below is the main(). It is only used when building this testcase on * its own for testing or for building a binary to use in testing binary * analysis tools. It is not used when compiling all the testcases as one * application, which is how source code analysis tools are tested. */ #ifdef INCLUDEMAIN int main(int argc, char * argv[]) { /* seed randomness */ srand( (unsigned)time(NULL) ); #ifndef OMITGOOD printLine("Calling good()..."); CWE78_OS_Command_Injection__char_listen_socket_w32_execv_13_good(); printLine("Finished good()"); #endif /* OMITGOOD */ #ifndef OMITBAD printLine("Calling bad()..."); CWE78_OS_Command_Injection__char_listen_socket_w32_execv_13_bad(); printLine("Finished bad()"); #endif /* OMITBAD */ return 0; } #endif

frank@fischer.com.mt

8b39fe097d9a0ad75f4e8e176acbcd3e9e6ce47c

5c255f911786e984286b1f7a4e6091a68419d049

/code/24fbc88b-b066-449c-ae5b-a5acd378d8ab.c

6c6cfa7dc48bd7868bbeecf6b19c39cd6bf27ae4

no_license

nmharmon8/Deep-Buffer-Overflow-Detection

70fe02c8dc75d12e91f5bc4468cf260e490af1a4

e0c86210c86afb07c8d4abcc957c7f1b252b4eb2

refs/heads/master

UTF-8

C

c

#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 = l/j; l = k-j*i; printf("vulnerability"); printf("%d%d\n",l,l); return 0; }

nharmon8@gmail.com

ff3959dcfefc32276c08841c6534ca13f08bec63

d24750e5c892c961ebc316484e27de11774db135

/Src/VL53l1X.c

9130b1f3476a4024ec8ee467dd98e7873227adac

no_license

MarcusCorbin1/Number12

3bc4f46a59bfd1f29a3ac61c214409eb43e2cdae

0069173892eb944d12c0b6c9ee8a8dd2b52c481b

refs/heads/master

UTF-8

C

c

#include "stm32l4xx_hal.h" #include "VL53l1X.h" //Start the Data Initializer void VL53L1_DataInit(I2C_HandleTypeDef i2cHandle) { uint8_t buffer[12]; buffer[0] = 0x88; buffer[1] = 0x00; HAL_I2C_Master_Transmit(&i2cHandle, 0x52, buffer, 2, 100); HAL_Delay(20); } //Start the Static Initializer void VL53L1_StaticInit(I2C_HandleTypeDef i2cHandle) { uint8_t buffer[12]; buffer[0] = 0xFF; buffer[1] = 0x01; HAL_I2C_Master_Transmit(&i2cHandle, 0x52, buffer, 2, 100); uint16_t tempword = 0; buffer[0] = 0xFF; buffer[1] = tempword; HAL_I2C_Master_Receive(&i2cHandle, 0x53, buffer, 2, 100); buffer[0] = 0xFF; buffer[1] = 0x00; HAL_I2C_Master_Transmit(&i2cHandle, 0x52, buffer, 2, 100); } // This function will get the measurement ready void VL53L1_StartMeasurement(I2C_HandleTypeDef i2cHandle) { uint8_t buffer[64]; buffer[0] = 0x000; buffer[1] = 0x01; HAL_I2C_Master_Transmit(&i2cHandle, 0x52, buffer, 2, 100); }

marcus.corbin@itron.com

681714c9a7576083efca3998c82af18ed07b3562

99166976f3e170ad5d9fb2840b1c0ade2182a2c3

/libs/rh4n_ldaparser/src/rh4n_lda_array.c

18cc3aecdc99a46678399d32d905ecce91675310

no_license

audacity363/natAWSWrapper

18acda09518788ae22c78b797e65ec3e3cd0531a

e99ed02d465ba9e6a3234ac30563b00d612d4d46

refs/heads/master

UTF-8

C

c

#include <stdio.h> #include <stdlib.h> #include <errno.h> #include <string.h> #include "rh4n.h" #include "rh4n_ldaparser.h" int rh4nldaGetArrayType(char *line, int *dimensions, int length[3], RH4nProperties *props, char *errorstr) { *dimensions= 0; char *end_var_params = NULL, *comma = NULL, *double_collon = NULL; if((end_var_params = strchr(line, ')')) == NULL) { sprintf(errorstr, "Can not find array parms end"); rh4n_log_error(props->logging, "%s", errorstr); return(RH4N_RET_LDA_PARSE_ERR); } *end_var_params = 0x00; comma = rh4nldastrtok(line, ','); while(comma) { (*dimensions)++; //Check if a lower bound is specified if((double_collon = strchr(comma, ':')) != NULL) { *double_collon = 0x00; double_collon++; length[(*dimensions)-1] = atoi(double_collon); } else { length[(*dimensions)-1] = atoi(comma); } comma = rh4nldastrtok(NULL, ','); } return(RH4N_RET_OK); }

tom@engemann.me

51fbad2bfeb09528ca3cb36ba6098eb1c9816eff

25ba673dae94a65d02989d8b72aa4ebda00b0652

/예제9-6.c

c28ba2aeede8768fa8a3d745203496296575bb28

no_license

mykid7/C

3c72d2414ba4a9ae889d57702468ccbfea19796a

23d1de46d313521a53cb957014f492e3165cff17

refs/heads/master

UHC

C

c

#include <stdio.h> int main(void) { int a = 10; // 변수 선언과 초기화 int *p = &a; // 포인터 선언과 동시에 a를 가리키도록 초기화 double *pd; // double형 변수를 가리키는 포인터 pd = p; // 포인터 p 값을 포인터 pd에 대입 printf("%lf\n", *pd); // pd가 가리키는 변수의 값 출력 return 0; }

noreply@github.com

b9311b53de5dc8ddfc8a8845a13274fc158e332a

263589b8c63adc45a5dcecf5ba7178a0f40a8646

/samd21a/include/component/dsu.h

7a51d9b738c4439d7a787fd8ff031b5446822a17

no_license

joaofl/xdense-cortexm1

c6b1f181305726c951e352eccb4b50c0f4a7d994

224e9aae27f39692dd98a5c10057b32b9958792a

refs/heads/main

UTF-8

C

h

/** * \file * * \brief Component description for DSU * * Copyright (c) 2016 Atmel Corporation, * a wholly owned subsidiary of Microchip Technology Inc. * * \asf_license_start * * \page License * * 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 Licence 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. * * \asf_license_stop * */ #ifndef _SAMD21_DSU_COMPONENT_ #define _SAMD21_DSU_COMPONENT_ /* ========================================================================== */ /** SOFTWARE API DEFINITION FOR DSU */ /* ========================================================================== */ /** \addtogroup SAMD21_DSU Device Service Unit */ /*@{*/ #define DSU_U2209 #define REV_DSU 0x200 /* -------- DSU_CTRL : (DSU Offset: 0x0000) ( /W 8) Control -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint8_t SWRST:1; /*!< bit: 0 Software Reset */ uint8_t :1; /*!< bit: 1 Reserved */ uint8_t CRC:1; /*!< bit: 2 32-bit Cyclic Redundancy Check */ uint8_t MBIST:1; /*!< bit: 3 Memory Built-In Self-Test */ uint8_t CE:1; /*!< bit: 4 Chip Erase */ uint8_t :3; /*!< bit: 5.. 7 Reserved */ } bit; /*!< Structure used for bit access */ uint8_t reg; /*!< Type used for register access */ } DSU_CTRL_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_CTRL_OFFSET 0x0000 /**< \brief (DSU_CTRL offset) Control */ #define DSU_CTRL_RESETVALUE _U(0x00) /**< \brief (DSU_CTRL reset_value) Control */ #define DSU_CTRL_SWRST_Pos 0 /**< \brief (DSU_CTRL) Software Reset */ #define DSU_CTRL_SWRST (_U(0x1) << DSU_CTRL_SWRST_Pos) #define DSU_CTRL_CRC_Pos 2 /**< \brief (DSU_CTRL) 32-bit Cyclic Redundancy Check */ #define DSU_CTRL_CRC (_U(0x1) << DSU_CTRL_CRC_Pos) #define DSU_CTRL_MBIST_Pos 3 /**< \brief (DSU_CTRL) Memory Built-In Self-Test */ #define DSU_CTRL_MBIST (_U(0x1) << DSU_CTRL_MBIST_Pos) #define DSU_CTRL_CE_Pos 4 /**< \brief (DSU_CTRL) Chip Erase */ #define DSU_CTRL_CE (_U(0x1) << DSU_CTRL_CE_Pos) #define DSU_CTRL_MASK _U(0x1D) /**< \brief (DSU_CTRL) MASK Register */ /* -------- DSU_STATUSA : (DSU Offset: 0x0001) (R/W 8) Status A -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint8_t DONE:1; /*!< bit: 0 Done */ uint8_t CRSTEXT:1; /*!< bit: 1 CPU Reset Phase Extension */ uint8_t BERR:1; /*!< bit: 2 Bus Error */ uint8_t FAIL:1; /*!< bit: 3 Failure */ uint8_t PERR:1; /*!< bit: 4 Protection Error */ uint8_t :3; /*!< bit: 5.. 7 Reserved */ } bit; /*!< Structure used for bit access */ uint8_t reg; /*!< Type used for register access */ } DSU_STATUSA_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_STATUSA_OFFSET 0x0001 /**< \brief (DSU_STATUSA offset) Status A */ #define DSU_STATUSA_RESETVALUE _U(0x00) /**< \brief (DSU_STATUSA reset_value) Status A */ #define DSU_STATUSA_DONE_Pos 0 /**< \brief (DSU_STATUSA) Done */ #define DSU_STATUSA_DONE (_U(0x1) << DSU_STATUSA_DONE_Pos) #define DSU_STATUSA_CRSTEXT_Pos 1 /**< \brief (DSU_STATUSA) CPU Reset Phase Extension */ #define DSU_STATUSA_CRSTEXT (_U(0x1) << DSU_STATUSA_CRSTEXT_Pos) #define DSU_STATUSA_BERR_Pos 2 /**< \brief (DSU_STATUSA) Bus Error */ #define DSU_STATUSA_BERR (_U(0x1) << DSU_STATUSA_BERR_Pos) #define DSU_STATUSA_FAIL_Pos 3 /**< \brief (DSU_STATUSA) Failure */ #define DSU_STATUSA_FAIL (_U(0x1) << DSU_STATUSA_FAIL_Pos) #define DSU_STATUSA_PERR_Pos 4 /**< \brief (DSU_STATUSA) Protection Error */ #define DSU_STATUSA_PERR (_U(0x1) << DSU_STATUSA_PERR_Pos) #define DSU_STATUSA_MASK _U(0x1F) /**< \brief (DSU_STATUSA) MASK Register */ /* -------- DSU_STATUSB : (DSU Offset: 0x0002) (R/ 8) Status B -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint8_t PROT:1; /*!< bit: 0 Protected */ uint8_t DBGPRES:1; /*!< bit: 1 Debugger Present */ uint8_t DCCD0:1; /*!< bit: 2 Debug Communication Channel 0 Dirty */ uint8_t DCCD1:1; /*!< bit: 3 Debug Communication Channel 1 Dirty */ uint8_t HPE:1; /*!< bit: 4 Hot-Plugging Enable */ uint8_t :3; /*!< bit: 5.. 7 Reserved */ } bit; /*!< Structure used for bit access */ struct { uint8_t :2; /*!< bit: 0.. 1 Reserved */ uint8_t DCCD:2; /*!< bit: 2.. 3 Debug Communication Channel x Dirty */ uint8_t :4; /*!< bit: 4.. 7 Reserved */ } vec; /*!< Structure used for vec access */ uint8_t reg; /*!< Type used for register access */ } DSU_STATUSB_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_STATUSB_OFFSET 0x0002 /**< \brief (DSU_STATUSB offset) Status B */ #define DSU_STATUSB_RESETVALUE _U(0x10) /**< \brief (DSU_STATUSB reset_value) Status B */ #define DSU_STATUSB_PROT_Pos 0 /**< \brief (DSU_STATUSB) Protected */ #define DSU_STATUSB_PROT (_U(0x1) << DSU_STATUSB_PROT_Pos) #define DSU_STATUSB_DBGPRES_Pos 1 /**< \brief (DSU_STATUSB) Debugger Present */ #define DSU_STATUSB_DBGPRES (_U(0x1) << DSU_STATUSB_DBGPRES_Pos) #define DSU_STATUSB_DCCD0_Pos 2 /**< \brief (DSU_STATUSB) Debug Communication Channel 0 Dirty */ #define DSU_STATUSB_DCCD0 (1 << DSU_STATUSB_DCCD0_Pos) #define DSU_STATUSB_DCCD1_Pos 3 /**< \brief (DSU_STATUSB) Debug Communication Channel 1 Dirty */ #define DSU_STATUSB_DCCD1 (1 << DSU_STATUSB_DCCD1_Pos) #define DSU_STATUSB_DCCD_Pos 2 /**< \brief (DSU_STATUSB) Debug Communication Channel x Dirty */ #define DSU_STATUSB_DCCD_Msk (_U(0x3) << DSU_STATUSB_DCCD_Pos) #define DSU_STATUSB_DCCD(value) (DSU_STATUSB_DCCD_Msk & ((value) << DSU_STATUSB_DCCD_Pos)) #define DSU_STATUSB_HPE_Pos 4 /**< \brief (DSU_STATUSB) Hot-Plugging Enable */ #define DSU_STATUSB_HPE (_U(0x1) << DSU_STATUSB_HPE_Pos) #define DSU_STATUSB_MASK _U(0x1F) /**< \brief (DSU_STATUSB) MASK Register */ /* -------- DSU_ADDR : (DSU Offset: 0x0004) (R/W 32) Address -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint32_t :2; /*!< bit: 0.. 1 Reserved */ uint32_t ADDR:30; /*!< bit: 2..31 Address */ } bit; /*!< Structure used for bit access */ uint32_t reg; /*!< Type used for register access */ } DSU_ADDR_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_ADDR_OFFSET 0x0004 /**< \brief (DSU_ADDR offset) Address */ #define DSU_ADDR_RESETVALUE _U(0x00000000) /**< \brief (DSU_ADDR reset_value) Address */ #define DSU_ADDR_ADDR_Pos 2 /**< \brief (DSU_ADDR) Address */ #define DSU_ADDR_ADDR_Msk (_U(0x3FFFFFFF) << DSU_ADDR_ADDR_Pos) #define DSU_ADDR_ADDR(value) (DSU_ADDR_ADDR_Msk & ((value) << DSU_ADDR_ADDR_Pos)) #define DSU_ADDR_MASK _U(0xFFFFFFFC) /**< \brief (DSU_ADDR) MASK Register */ /* -------- DSU_LENGTH : (DSU Offset: 0x0008) (R/W 32) Length -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint32_t :2; /*!< bit: 0.. 1 Reserved */ uint32_t LENGTH:30; /*!< bit: 2..31 Length */ } bit; /*!< Structure used for bit access */ uint32_t reg; /*!< Type used for register access */ } DSU_LENGTH_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_LENGTH_OFFSET 0x0008 /**< \brief (DSU_LENGTH offset) Length */ #define DSU_LENGTH_RESETVALUE _U(0x00000000) /**< \brief (DSU_LENGTH reset_value) Length */ #define DSU_LENGTH_LENGTH_Pos 2 /**< \brief (DSU_LENGTH) Length */ #define DSU_LENGTH_LENGTH_Msk (_U(0x3FFFFFFF) << DSU_LENGTH_LENGTH_Pos) #define DSU_LENGTH_LENGTH(value) (DSU_LENGTH_LENGTH_Msk & ((value) << DSU_LENGTH_LENGTH_Pos)) #define DSU_LENGTH_MASK _U(0xFFFFFFFC) /**< \brief (DSU_LENGTH) MASK Register */ /* -------- DSU_DATA : (DSU Offset: 0x000C) (R/W 32) Data -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint32_t DATA:32; /*!< bit: 0..31 Data */ } bit; /*!< Structure used for bit access */ uint32_t reg; /*!< Type used for register access */ } DSU_DATA_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_DATA_OFFSET 0x000C /**< \brief (DSU_DATA offset) Data */ #define DSU_DATA_RESETVALUE _U(0x00000000) /**< \brief (DSU_DATA reset_value) Data */ #define DSU_DATA_DATA_Pos 0 /**< \brief (DSU_DATA) Data */ #define DSU_DATA_DATA_Msk (_U(0xFFFFFFFF) << DSU_DATA_DATA_Pos) #define DSU_DATA_DATA(value) (DSU_DATA_DATA_Msk & ((value) << DSU_DATA_DATA_Pos)) #define DSU_DATA_MASK _U(0xFFFFFFFF) /**< \brief (DSU_DATA) MASK Register */ /* -------- DSU_DCC : (DSU Offset: 0x0010) (R/W 32) Debug Communication Channel n -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint32_t DATA:32; /*!< bit: 0..31 Data */ } bit; /*!< Structure used for bit access */ uint32_t reg; /*!< Type used for register access */ } DSU_DCC_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_DCC_OFFSET 0x0010 /**< \brief (DSU_DCC offset) Debug Communication Channel n */ #define DSU_DCC_RESETVALUE _U(0x00000000) /**< \brief (DSU_DCC reset_value) Debug Communication Channel n */ #define DSU_DCC_DATA_Pos 0 /**< \brief (DSU_DCC) Data */ #define DSU_DCC_DATA_Msk (_U(0xFFFFFFFF) << DSU_DCC_DATA_Pos) #define DSU_DCC_DATA(value) (DSU_DCC_DATA_Msk & ((value) << DSU_DCC_DATA_Pos)) #define DSU_DCC_MASK _U(0xFFFFFFFF) /**< \brief (DSU_DCC) MASK Register */ /* -------- DSU_DID : (DSU Offset: 0x0018) (R/ 32) Device Identification -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint32_t DEVSEL:8; /*!< bit: 0.. 7 Device Select */ uint32_t REVISION:4; /*!< bit: 8..11 Revision */ uint32_t DIE:4; /*!< bit: 12..15 Die Identification */ uint32_t SERIES:6; /*!< bit: 16..21 Product Series */ uint32_t :1; /*!< bit: 22 Reserved */ uint32_t FAMILY:5; /*!< bit: 23..27 Product Family */ uint32_t PROCESSOR:4; /*!< bit: 28..31 Processor */ } bit; /*!< Structure used for bit access */ uint32_t reg; /*!< Type used for register access */ } DSU_DID_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_DID_OFFSET 0x0018 /**< \brief (DSU_DID offset) Device Identification */ #define DSU_DID_DEVSEL_Pos 0 /**< \brief (DSU_DID) Device Select */ #define DSU_DID_DEVSEL_Msk (_U(0xFF) << DSU_DID_DEVSEL_Pos) #define DSU_DID_DEVSEL(value) (DSU_DID_DEVSEL_Msk & ((value) << DSU_DID_DEVSEL_Pos)) #define DSU_DID_REVISION_Pos 8 /**< \brief (DSU_DID) Revision */ #define DSU_DID_REVISION_Msk (_U(0xF) << DSU_DID_REVISION_Pos) #define DSU_DID_REVISION(value) (DSU_DID_REVISION_Msk & ((value) << DSU_DID_REVISION_Pos)) #define DSU_DID_DIE_Pos 12 /**< \brief (DSU_DID) Die Identification */ #define DSU_DID_DIE_Msk (_U(0xF) << DSU_DID_DIE_Pos) #define DSU_DID_DIE(value) (DSU_DID_DIE_Msk & ((value) << DSU_DID_DIE_Pos)) #define DSU_DID_SERIES_Pos 16 /**< \brief (DSU_DID) Product Series */ #define DSU_DID_SERIES_Msk (_U(0x3F) << DSU_DID_SERIES_Pos) #define DSU_DID_SERIES(value) (DSU_DID_SERIES_Msk & ((value) << DSU_DID_SERIES_Pos)) #define DSU_DID_FAMILY_Pos 23 /**< \brief (DSU_DID) Product Family */ #define DSU_DID_FAMILY_Msk (_U(0x1F) << DSU_DID_FAMILY_Pos) #define DSU_DID_FAMILY(value) (DSU_DID_FAMILY_Msk & ((value) << DSU_DID_FAMILY_Pos)) #define DSU_DID_PROCESSOR_Pos 28 /**< \brief (DSU_DID) Processor */ #define DSU_DID_PROCESSOR_Msk (_U(0xF) << DSU_DID_PROCESSOR_Pos) #define DSU_DID_PROCESSOR(value) (DSU_DID_PROCESSOR_Msk & ((value) << DSU_DID_PROCESSOR_Pos)) #define DSU_DID_MASK _U(0xFFBFFFFF) /**< \brief (DSU_DID) MASK Register */ /* -------- DSU_ENTRY : (DSU Offset: 0x1000) (R/ 32) Coresight ROM Table Entry n -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint32_t EPRES:1; /*!< bit: 0 Entry Present */ uint32_t FMT:1; /*!< bit: 1 Format */ uint32_t :10; /*!< bit: 2..11 Reserved */ uint32_t ADDOFF:20; /*!< bit: 12..31 Address Offset */ } bit; /*!< Structure used for bit access */ uint32_t reg; /*!< Type used for register access */ } DSU_ENTRY_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_ENTRY_OFFSET 0x1000 /**< \brief (DSU_ENTRY offset) Coresight ROM Table Entry n */ #define DSU_ENTRY_RESETVALUE _U(0x00000002) /**< \brief (DSU_ENTRY reset_value) Coresight ROM Table Entry n */ #define DSU_ENTRY_EPRES_Pos 0 /**< \brief (DSU_ENTRY) Entry Present */ #define DSU_ENTRY_EPRES (_U(0x1) << DSU_ENTRY_EPRES_Pos) #define DSU_ENTRY_FMT_Pos 1 /**< \brief (DSU_ENTRY) Format */ #define DSU_ENTRY_FMT (_U(0x1) << DSU_ENTRY_FMT_Pos) #define DSU_ENTRY_ADDOFF_Pos 12 /**< \brief (DSU_ENTRY) Address Offset */ #define DSU_ENTRY_ADDOFF_Msk (_U(0xFFFFF) << DSU_ENTRY_ADDOFF_Pos) #define DSU_ENTRY_ADDOFF(value) (DSU_ENTRY_ADDOFF_Msk & ((value) << DSU_ENTRY_ADDOFF_Pos)) #define DSU_ENTRY_MASK _U(0xFFFFF003) /**< \brief (DSU_ENTRY) MASK Register */ /* -------- DSU_END : (DSU Offset: 0x1008) (R/ 32) Coresight ROM Table End -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint32_t END:32; /*!< bit: 0..31 End Marker */ } bit; /*!< Structure used for bit access */ uint32_t reg; /*!< Type used for register access */ } DSU_END_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_END_OFFSET 0x1008 /**< \brief (DSU_END offset) Coresight ROM Table End */ #define DSU_END_RESETVALUE _U(0x00000000) /**< \brief (DSU_END reset_value) Coresight ROM Table End */ #define DSU_END_END_Pos 0 /**< \brief (DSU_END) End Marker */ #define DSU_END_END_Msk (_U(0xFFFFFFFF) << DSU_END_END_Pos) #define DSU_END_END(value) (DSU_END_END_Msk & ((value) << DSU_END_END_Pos)) #define DSU_END_MASK _U(0xFFFFFFFF) /**< \brief (DSU_END) MASK Register */ /* -------- DSU_MEMTYPE : (DSU Offset: 0x1FCC) (R/ 32) Coresight ROM Table Memory Type -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint32_t SMEMP:1; /*!< bit: 0 System Memory Present */ uint32_t :31; /*!< bit: 1..31 Reserved */ } bit; /*!< Structure used for bit access */ uint32_t reg; /*!< Type used for register access */ } DSU_MEMTYPE_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_MEMTYPE_OFFSET 0x1FCC /**< \brief (DSU_MEMTYPE offset) Coresight ROM Table Memory Type */ #define DSU_MEMTYPE_RESETVALUE _U(0x00000000) /**< \brief (DSU_MEMTYPE reset_value) Coresight ROM Table Memory Type */ #define DSU_MEMTYPE_SMEMP_Pos 0 /**< \brief (DSU_MEMTYPE) System Memory Present */ #define DSU_MEMTYPE_SMEMP (_U(0x1) << DSU_MEMTYPE_SMEMP_Pos) #define DSU_MEMTYPE_MASK _U(0x00000001) /**< \brief (DSU_MEMTYPE) MASK Register */ /* -------- DSU_PID4 : (DSU Offset: 0x1FD0) (R/ 32) Peripheral Identification 4 -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint32_t JEPCC:4; /*!< bit: 0.. 3 JEP-106 Continuation Code */ uint32_t FKBC:4; /*!< bit: 4.. 7 4KB Count */ uint32_t :24; /*!< bit: 8..31 Reserved */ } bit; /*!< Structure used for bit access */ uint32_t reg; /*!< Type used for register access */ } DSU_PID4_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_PID4_OFFSET 0x1FD0 /**< \brief (DSU_PID4 offset) Peripheral Identification 4 */ #define DSU_PID4_RESETVALUE _U(0x00000000) /**< \brief (DSU_PID4 reset_value) Peripheral Identification 4 */ #define DSU_PID4_JEPCC_Pos 0 /**< \brief (DSU_PID4) JEP-106 Continuation Code */ #define DSU_PID4_JEPCC_Msk (_U(0xF) << DSU_PID4_JEPCC_Pos) #define DSU_PID4_JEPCC(value) (DSU_PID4_JEPCC_Msk & ((value) << DSU_PID4_JEPCC_Pos)) #define DSU_PID4_FKBC_Pos 4 /**< \brief (DSU_PID4) 4KB Count */ #define DSU_PID4_FKBC_Msk (_U(0xF) << DSU_PID4_FKBC_Pos) #define DSU_PID4_FKBC(value) (DSU_PID4_FKBC_Msk & ((value) << DSU_PID4_FKBC_Pos)) #define DSU_PID4_MASK _U(0x000000FF) /**< \brief (DSU_PID4) MASK Register */ /* -------- DSU_PID0 : (DSU Offset: 0x1FE0) (R/ 32) Peripheral Identification 0 -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint32_t PARTNBL:8; /*!< bit: 0.. 7 Part Number Low */ uint32_t :24; /*!< bit: 8..31 Reserved */ } bit; /*!< Structure used for bit access */ uint32_t reg; /*!< Type used for register access */ } DSU_PID0_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_PID0_OFFSET 0x1FE0 /**< \brief (DSU_PID0 offset) Peripheral Identification 0 */ #define DSU_PID0_RESETVALUE _U(0x000000D0) /**< \brief (DSU_PID0 reset_value) Peripheral Identification 0 */ #define DSU_PID0_PARTNBL_Pos 0 /**< \brief (DSU_PID0) Part Number Low */ #define DSU_PID0_PARTNBL_Msk (_U(0xFF) << DSU_PID0_PARTNBL_Pos) #define DSU_PID0_PARTNBL(value) (DSU_PID0_PARTNBL_Msk & ((value) << DSU_PID0_PARTNBL_Pos)) #define DSU_PID0_MASK _U(0x000000FF) /**< \brief (DSU_PID0) MASK Register */ /* -------- DSU_PID1 : (DSU Offset: 0x1FE4) (R/ 32) Peripheral Identification 1 -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint32_t PARTNBH:4; /*!< bit: 0.. 3 Part Number High */ uint32_t JEPIDCL:4; /*!< bit: 4.. 7 Low part of the JEP-106 Identity Code */ uint32_t :24; /*!< bit: 8..31 Reserved */ } bit; /*!< Structure used for bit access */ uint32_t reg; /*!< Type used for register access */ } DSU_PID1_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_PID1_OFFSET 0x1FE4 /**< \brief (DSU_PID1 offset) Peripheral Identification 1 */ #define DSU_PID1_RESETVALUE _U(0x000000FC) /**< \brief (DSU_PID1 reset_value) Peripheral Identification 1 */ #define DSU_PID1_PARTNBH_Pos 0 /**< \brief (DSU_PID1) Part Number High */ #define DSU_PID1_PARTNBH_Msk (_U(0xF) << DSU_PID1_PARTNBH_Pos) #define DSU_PID1_PARTNBH(value) (DSU_PID1_PARTNBH_Msk & ((value) << DSU_PID1_PARTNBH_Pos)) #define DSU_PID1_JEPIDCL_Pos 4 /**< \brief (DSU_PID1) Low part of the JEP-106 Identity Code */ #define DSU_PID1_JEPIDCL_Msk (_U(0xF) << DSU_PID1_JEPIDCL_Pos) #define DSU_PID1_JEPIDCL(value) (DSU_PID1_JEPIDCL_Msk & ((value) << DSU_PID1_JEPIDCL_Pos)) #define DSU_PID1_MASK _U(0x000000FF) /**< \brief (DSU_PID1) MASK Register */ /* -------- DSU_PID2 : (DSU Offset: 0x1FE8) (R/ 32) Peripheral Identification 2 -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint32_t JEPIDCH:3; /*!< bit: 0.. 2 JEP-106 Identity Code High */ uint32_t JEPU:1; /*!< bit: 3 JEP-106 Identity Code is used */ uint32_t REVISION:4; /*!< bit: 4.. 7 Revision Number */ uint32_t :24; /*!< bit: 8..31 Reserved */ } bit; /*!< Structure used for bit access */ uint32_t reg; /*!< Type used for register access */ } DSU_PID2_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_PID2_OFFSET 0x1FE8 /**< \brief (DSU_PID2 offset) Peripheral Identification 2 */ #define DSU_PID2_RESETVALUE _U(0x00000009) /**< \brief (DSU_PID2 reset_value) Peripheral Identification 2 */ #define DSU_PID2_JEPIDCH_Pos 0 /**< \brief (DSU_PID2) JEP-106 Identity Code High */ #define DSU_PID2_JEPIDCH_Msk (_U(0x7) << DSU_PID2_JEPIDCH_Pos) #define DSU_PID2_JEPIDCH(value) (DSU_PID2_JEPIDCH_Msk & ((value) << DSU_PID2_JEPIDCH_Pos)) #define DSU_PID2_JEPU_Pos 3 /**< \brief (DSU_PID2) JEP-106 Identity Code is used */ #define DSU_PID2_JEPU (_U(0x1) << DSU_PID2_JEPU_Pos) #define DSU_PID2_REVISION_Pos 4 /**< \brief (DSU_PID2) Revision Number */ #define DSU_PID2_REVISION_Msk (_U(0xF) << DSU_PID2_REVISION_Pos) #define DSU_PID2_REVISION(value) (DSU_PID2_REVISION_Msk & ((value) << DSU_PID2_REVISION_Pos)) #define DSU_PID2_MASK _U(0x000000FF) /**< \brief (DSU_PID2) MASK Register */ /* -------- DSU_PID3 : (DSU Offset: 0x1FEC) (R/ 32) Peripheral Identification 3 -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint32_t CUSMOD:4; /*!< bit: 0.. 3 ARM CUSMOD */ uint32_t REVAND:4; /*!< bit: 4.. 7 Revision Number */ uint32_t :24; /*!< bit: 8..31 Reserved */ } bit; /*!< Structure used for bit access */ uint32_t reg; /*!< Type used for register access */ } DSU_PID3_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_PID3_OFFSET 0x1FEC /**< \brief (DSU_PID3 offset) Peripheral Identification 3 */ #define DSU_PID3_RESETVALUE _U(0x00000000) /**< \brief (DSU_PID3 reset_value) Peripheral Identification 3 */ #define DSU_PID3_CUSMOD_Pos 0 /**< \brief (DSU_PID3) ARM CUSMOD */ #define DSU_PID3_CUSMOD_Msk (_U(0xF) << DSU_PID3_CUSMOD_Pos) #define DSU_PID3_CUSMOD(value) (DSU_PID3_CUSMOD_Msk & ((value) << DSU_PID3_CUSMOD_Pos)) #define DSU_PID3_REVAND_Pos 4 /**< \brief (DSU_PID3) Revision Number */ #define DSU_PID3_REVAND_Msk (_U(0xF) << DSU_PID3_REVAND_Pos) #define DSU_PID3_REVAND(value) (DSU_PID3_REVAND_Msk & ((value) << DSU_PID3_REVAND_Pos)) #define DSU_PID3_MASK _U(0x000000FF) /**< \brief (DSU_PID3) MASK Register */ /* -------- DSU_CID0 : (DSU Offset: 0x1FF0) (R/ 32) Component Identification 0 -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint32_t PREAMBLEB0:8; /*!< bit: 0.. 7 Preamble Byte 0 */ uint32_t :24; /*!< bit: 8..31 Reserved */ } bit; /*!< Structure used for bit access */ uint32_t reg; /*!< Type used for register access */ } DSU_CID0_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_CID0_OFFSET 0x1FF0 /**< \brief (DSU_CID0 offset) Component Identification 0 */ #define DSU_CID0_RESETVALUE _U(0x0000000D) /**< \brief (DSU_CID0 reset_value) Component Identification 0 */ #define DSU_CID0_PREAMBLEB0_Pos 0 /**< \brief (DSU_CID0) Preamble Byte 0 */ #define DSU_CID0_PREAMBLEB0_Msk (_U(0xFF) << DSU_CID0_PREAMBLEB0_Pos) #define DSU_CID0_PREAMBLEB0(value) (DSU_CID0_PREAMBLEB0_Msk & ((value) << DSU_CID0_PREAMBLEB0_Pos)) #define DSU_CID0_MASK _U(0x000000FF) /**< \brief (DSU_CID0) MASK Register */ /* -------- DSU_CID1 : (DSU Offset: 0x1FF4) (R/ 32) Component Identification 1 -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint32_t PREAMBLE:4; /*!< bit: 0.. 3 Preamble */ uint32_t CCLASS:4; /*!< bit: 4.. 7 Component Class */ uint32_t :24; /*!< bit: 8..31 Reserved */ } bit; /*!< Structure used for bit access */ uint32_t reg; /*!< Type used for register access */ } DSU_CID1_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_CID1_OFFSET 0x1FF4 /**< \brief (DSU_CID1 offset) Component Identification 1 */ #define DSU_CID1_RESETVALUE _U(0x00000010) /**< \brief (DSU_CID1 reset_value) Component Identification 1 */ #define DSU_CID1_PREAMBLE_Pos 0 /**< \brief (DSU_CID1) Preamble */ #define DSU_CID1_PREAMBLE_Msk (_U(0xF) << DSU_CID1_PREAMBLE_Pos) #define DSU_CID1_PREAMBLE(value) (DSU_CID1_PREAMBLE_Msk & ((value) << DSU_CID1_PREAMBLE_Pos)) #define DSU_CID1_CCLASS_Pos 4 /**< \brief (DSU_CID1) Component Class */ #define DSU_CID1_CCLASS_Msk (_U(0xF) << DSU_CID1_CCLASS_Pos) #define DSU_CID1_CCLASS(value) (DSU_CID1_CCLASS_Msk & ((value) << DSU_CID1_CCLASS_Pos)) #define DSU_CID1_MASK _U(0x000000FF) /**< \brief (DSU_CID1) MASK Register */ /* -------- DSU_CID2 : (DSU Offset: 0x1FF8) (R/ 32) Component Identification 2 -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint32_t PREAMBLEB2:8; /*!< bit: 0.. 7 Preamble Byte 2 */ uint32_t :24; /*!< bit: 8..31 Reserved */ } bit; /*!< Structure used for bit access */ uint32_t reg; /*!< Type used for register access */ } DSU_CID2_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_CID2_OFFSET 0x1FF8 /**< \brief (DSU_CID2 offset) Component Identification 2 */ #define DSU_CID2_RESETVALUE _U(0x00000005) /**< \brief (DSU_CID2 reset_value) Component Identification 2 */ #define DSU_CID2_PREAMBLEB2_Pos 0 /**< \brief (DSU_CID2) Preamble Byte 2 */ #define DSU_CID2_PREAMBLEB2_Msk (_U(0xFF) << DSU_CID2_PREAMBLEB2_Pos) #define DSU_CID2_PREAMBLEB2(value) (DSU_CID2_PREAMBLEB2_Msk & ((value) << DSU_CID2_PREAMBLEB2_Pos)) #define DSU_CID2_MASK _U(0x000000FF) /**< \brief (DSU_CID2) MASK Register */ /* -------- DSU_CID3 : (DSU Offset: 0x1FFC) (R/ 32) Component Identification 3 -------- */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef union { struct { uint32_t PREAMBLEB3:8; /*!< bit: 0.. 7 Preamble Byte 3 */ uint32_t :24; /*!< bit: 8..31 Reserved */ } bit; /*!< Structure used for bit access */ uint32_t reg; /*!< Type used for register access */ } DSU_CID3_Type; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ #define DSU_CID3_OFFSET 0x1FFC /**< \brief (DSU_CID3 offset) Component Identification 3 */ #define DSU_CID3_RESETVALUE _U(0x000000B1) /**< \brief (DSU_CID3 reset_value) Component Identification 3 */ #define DSU_CID3_PREAMBLEB3_Pos 0 /**< \brief (DSU_CID3) Preamble Byte 3 */ #define DSU_CID3_PREAMBLEB3_Msk (_U(0xFF) << DSU_CID3_PREAMBLEB3_Pos) #define DSU_CID3_PREAMBLEB3(value) (DSU_CID3_PREAMBLEB3_Msk & ((value) << DSU_CID3_PREAMBLEB3_Pos)) #define DSU_CID3_MASK _U(0x000000FF) /**< \brief (DSU_CID3) MASK Register */ /** \brief DSU hardware registers */ #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) typedef struct { __O DSU_CTRL_Type CTRL; /**< \brief Offset: 0x0000 ( /W 8) Control */ __IO DSU_STATUSA_Type STATUSA; /**< \brief Offset: 0x0001 (R/W 8) Status A */ __I DSU_STATUSB_Type STATUSB; /**< \brief Offset: 0x0002 (R/ 8) Status B */ RoReg8 Reserved1[0x1]; __IO DSU_ADDR_Type ADDR; /**< \brief Offset: 0x0004 (R/W 32) Address */ __IO DSU_LENGTH_Type LENGTH; /**< \brief Offset: 0x0008 (R/W 32) Length */ __IO DSU_DATA_Type DATA; /**< \brief Offset: 0x000C (R/W 32) Data */ __IO DSU_DCC_Type DCC[2]; /**< \brief Offset: 0x0010 (R/W 32) Debug Communication Channel n */ __I DSU_DID_Type DID; /**< \brief Offset: 0x0018 (R/ 32) Device Identification */ RoReg8 Reserved2[0xFE4]; __I DSU_ENTRY_Type ENTRY[2]; /**< \brief Offset: 0x1000 (R/ 32) Coresight ROM Table Entry n */ __I DSU_END_Type END; /**< \brief Offset: 0x1008 (R/ 32) Coresight ROM Table End */ RoReg8 Reserved3[0xFC0]; __I DSU_MEMTYPE_Type MEMTYPE; /**< \brief Offset: 0x1FCC (R/ 32) Coresight ROM Table Memory Type */ __I DSU_PID4_Type PID4; /**< \brief Offset: 0x1FD0 (R/ 32) Peripheral Identification 4 */ RoReg8 Reserved4[0xC]; __I DSU_PID0_Type PID0; /**< \brief Offset: 0x1FE0 (R/ 32) Peripheral Identification 0 */ __I DSU_PID1_Type PID1; /**< \brief Offset: 0x1FE4 (R/ 32) Peripheral Identification 1 */ __I DSU_PID2_Type PID2; /**< \brief Offset: 0x1FE8 (R/ 32) Peripheral Identification 2 */ __I DSU_PID3_Type PID3; /**< \brief Offset: 0x1FEC (R/ 32) Peripheral Identification 3 */ __I DSU_CID0_Type CID0; /**< \brief Offset: 0x1FF0 (R/ 32) Component Identification 0 */ __I DSU_CID1_Type CID1; /**< \brief Offset: 0x1FF4 (R/ 32) Component Identification 1 */ __I DSU_CID2_Type CID2; /**< \brief Offset: 0x1FF8 (R/ 32) Component Identification 2 */ __I DSU_CID3_Type CID3; /**< \brief Offset: 0x1FFC (R/ 32) Component Identification 3 */ } Dsu; #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ /*@}*/ #endif /* _SAMD21_DSU_COMPONENT_ */

joaofl@gmail.com

dfa01ea86a2bce6ee9052f2c25dae843b063fff3

f99fe5e7d6b160cef405cba7775899a81ed2a5e5

/src/cmptr3.c

f8f7532066b3e512f34a811e1517283e6b79cdc7

no_license

rajdipnayek/cslatec

83122616f72769b36fa7b6d00b3ec988bbb35fe3

c2a4301febfe44e2d1e0c0fa3a73ca49e44780db

refs/heads/master

UTF-8

C

c

/* cmptr3.f -- translated by f2c (version 12.02.01). You must link the resulting object file with libf2c: on Microsoft Windows system, link with libf2c.lib; on Linux or Unix systems, link with .../path/to/libf2c.a -lm or, if you install libf2c.a in a standard place, with -lf2c -lm -- in that order, at the end of the command line, as in cc *.o -lf2c -lm Source for libf2c is in /netlib/f2c/libf2c.zip, e.g., http://www.netlib.org/f2c/libf2c.zip */ #include <stdlib.h> /* For exit() */ #include <f2c.h> /* Table of constant values */ static complex c_b10 = {1.f,0.f}; /* DECK CMPTR3 */ /* Subroutine */ int cmptr3_(integer *m, complex *a, complex *b, complex *c__, integer *k, complex *y1, complex *y2, complex *y3, complex *tcos, complex *d__, complex *w1, complex *w2, complex *w3) { /* System generated locals */ integer i__1, i__2, i__3, i__4, i__5, i__6; complex q__1, q__2, q__3, q__4; /* Local variables */ static integer i__, n; static complex x, z__; static integer k1, k2, k3, k4, l1, l2, l3, ip; static complex xx; static integer mm1, k1p1, k2p1, k3p1, k4p1, k2k3k4, kint1, lint1, lint2, lint3, kint2, kint3; /* ***BEGIN PROLOGUE CMPTR3 */ /* ***SUBSIDIARY */ /* ***PURPOSE Subsidiary to CMGNBN */ /* ***LIBRARY SLATEC */ /* ***TYPE COMPLEX (TRI3-S, CMPTR3-C) */ /* ***AUTHOR (UNKNOWN) */ /* ***DESCRIPTION */ /* Subroutine to solve tridiagonal systems. */ /* ***SEE ALSO CMGNBN */ /* ***ROUTINES CALLED (NONE) */ /* ***REVISION HISTORY (YYMMDD) */ /* 801001 DATE WRITTEN */ /* 890206 REVISION DATE from Version 3.2 */ /* 891214 Prologue converted to Version 4.0 format. (BAB) */ /* 900402 Added TYPE section. (WRB) */ /* ***END PROLOGUE CMPTR3 */ /* ***FIRST EXECUTABLE STATEMENT CMPTR3 */ /* Parameter adjustments */ --w3; --w2; --w1; --d__; --tcos; --y3; --y2; --y1; --k; --c__; --b; --a; /* Function Body */ mm1 = *m - 1; k1 = k[1]; k2 = k[2]; k3 = k[3]; k4 = k[4]; k1p1 = k1 + 1; k2p1 = k2 + 1; k3p1 = k3 + 1; k4p1 = k4 + 1; k2k3k4 = k2 + k3 + k4; if (k2k3k4 == 0) { goto L101; } l1 = k1p1 / k2p1; l2 = k1p1 / k3p1; l3 = k1p1 / k4p1; lint1 = 1; lint2 = 1; lint3 = 1; kint1 = k1; kint2 = kint1 + k2; kint3 = kint2 + k3; L101: i__1 = k1; for (n = 1; n <= i__1; ++n) { i__2 = n; x.r = tcos[i__2].r, x.i = tcos[i__2].i; if (k2k3k4 == 0) { goto L107; } if (n != l1) { goto L103; } i__2 = *m; for (i__ = 1; i__ <= i__2; ++i__) { i__3 = i__; i__4 = i__; w1[i__3].r = y1[i__4].r, w1[i__3].i = y1[i__4].i; /* L102: */ } L103: if (n != l2) { goto L105; } i__2 = *m; for (i__ = 1; i__ <= i__2; ++i__) { i__3 = i__; i__4 = i__; w2[i__3].r = y2[i__4].r, w2[i__3].i = y2[i__4].i; /* L104: */ } L105: if (n != l3) { goto L107; } i__2 = *m; for (i__ = 1; i__ <= i__2; ++i__) { i__3 = i__; i__4 = i__; w3[i__3].r = y3[i__4].r, w3[i__3].i = y3[i__4].i; /* L106: */ } L107: q__2.r = b[1].r - x.r, q__2.i = b[1].i - x.i; c_div(&q__1, &c_b10, &q__2); z__.r = q__1.r, z__.i = q__1.i; q__1.r = c__[1].r * z__.r - c__[1].i * z__.i, q__1.i = c__[1].r * z__.i + c__[1].i * z__.r; d__[1].r = q__1.r, d__[1].i = q__1.i; q__1.r = y1[1].r * z__.r - y1[1].i * z__.i, q__1.i = y1[1].r * z__.i + y1[1].i * z__.r; y1[1].r = q__1.r, y1[1].i = q__1.i; q__1.r = y2[1].r * z__.r - y2[1].i * z__.i, q__1.i = y2[1].r * z__.i + y2[1].i * z__.r; y2[1].r = q__1.r, y2[1].i = q__1.i; q__1.r = y3[1].r * z__.r - y3[1].i * z__.i, q__1.i = y3[1].r * z__.i + y3[1].i * z__.r; y3[1].r = q__1.r, y3[1].i = q__1.i; i__2 = *m; for (i__ = 2; i__ <= i__2; ++i__) { i__3 = i__; q__3.r = b[i__3].r - x.r, q__3.i = b[i__3].i - x.i; i__4 = i__; i__5 = i__ - 1; q__4.r = a[i__4].r * d__[i__5].r - a[i__4].i * d__[i__5].i, q__4.i = a[i__4].r * d__[i__5].i + a[i__4].i * d__[i__5] .r; q__2.r = q__3.r - q__4.r, q__2.i = q__3.i - q__4.i; c_div(&q__1, &c_b10, &q__2); z__.r = q__1.r, z__.i = q__1.i; i__3 = i__; i__4 = i__; q__1.r = c__[i__4].r * z__.r - c__[i__4].i * z__.i, q__1.i = c__[ i__4].r * z__.i + c__[i__4].i * z__.r; d__[i__3].r = q__1.r, d__[i__3].i = q__1.i; i__3 = i__; i__4 = i__; i__5 = i__; i__6 = i__ - 1; q__3.r = a[i__5].r * y1[i__6].r - a[i__5].i * y1[i__6].i, q__3.i = a[i__5].r * y1[i__6].i + a[i__5].i * y1[i__6].r; q__2.r = y1[i__4].r - q__3.r, q__2.i = y1[i__4].i - q__3.i; q__1.r = q__2.r * z__.r - q__2.i * z__.i, q__1.i = q__2.r * z__.i + q__2.i * z__.r; y1[i__3].r = q__1.r, y1[i__3].i = q__1.i; i__3 = i__; i__4 = i__; i__5 = i__; i__6 = i__ - 1; q__3.r = a[i__5].r * y2[i__6].r - a[i__5].i * y2[i__6].i, q__3.i = a[i__5].r * y2[i__6].i + a[i__5].i * y2[i__6].r; q__2.r = y2[i__4].r - q__3.r, q__2.i = y2[i__4].i - q__3.i; q__1.r = q__2.r * z__.r - q__2.i * z__.i, q__1.i = q__2.r * z__.i + q__2.i * z__.r; y2[i__3].r = q__1.r, y2[i__3].i = q__1.i; i__3 = i__; i__4 = i__; i__5 = i__; i__6 = i__ - 1; q__3.r = a[i__5].r * y3[i__6].r - a[i__5].i * y3[i__6].i, q__3.i = a[i__5].r * y3[i__6].i + a[i__5].i * y3[i__6].r; q__2.r = y3[i__4].r - q__3.r, q__2.i = y3[i__4].i - q__3.i; q__1.r = q__2.r * z__.r - q__2.i * z__.i, q__1.i = q__2.r * z__.i + q__2.i * z__.r; y3[i__3].r = q__1.r, y3[i__3].i = q__1.i; /* L108: */ } i__2 = mm1; for (ip = 1; ip <= i__2; ++ip) { i__ = *m - ip; i__3 = i__; i__4 = i__; i__5 = i__; i__6 = i__ + 1; q__2.r = d__[i__5].r * y1[i__6].r - d__[i__5].i * y1[i__6].i, q__2.i = d__[i__5].r * y1[i__6].i + d__[i__5].i * y1[i__6] .r; q__1.r = y1[i__4].r - q__2.r, q__1.i = y1[i__4].i - q__2.i; y1[i__3].r = q__1.r, y1[i__3].i = q__1.i; i__3 = i__; i__4 = i__; i__5 = i__; i__6 = i__ + 1; q__2.r = d__[i__5].r * y2[i__6].r - d__[i__5].i * y2[i__6].i, q__2.i = d__[i__5].r * y2[i__6].i + d__[i__5].i * y2[i__6] .r; q__1.r = y2[i__4].r - q__2.r, q__1.i = y2[i__4].i - q__2.i; y2[i__3].r = q__1.r, y2[i__3].i = q__1.i; i__3 = i__; i__4 = i__; i__5 = i__; i__6 = i__ + 1; q__2.r = d__[i__5].r * y3[i__6].r - d__[i__5].i * y3[i__6].i, q__2.i = d__[i__5].r * y3[i__6].i + d__[i__5].i * y3[i__6] .r; q__1.r = y3[i__4].r - q__2.r, q__1.i = y3[i__4].i - q__2.i; y3[i__3].r = q__1.r, y3[i__3].i = q__1.i; /* L109: */ } if (k2k3k4 == 0) { goto L115; } if (n != l1) { goto L111; } i__ = lint1 + kint1; i__2 = i__; q__1.r = x.r - tcos[i__2].r, q__1.i = x.i - tcos[i__2].i; xx.r = q__1.r, xx.i = q__1.i; i__2 = *m; for (i__ = 1; i__ <= i__2; ++i__) { i__3 = i__; i__4 = i__; q__2.r = xx.r * y1[i__4].r - xx.i * y1[i__4].i, q__2.i = xx.r * y1[i__4].i + xx.i * y1[i__4].r; i__5 = i__; q__1.r = q__2.r + w1[i__5].r, q__1.i = q__2.i + w1[i__5].i; y1[i__3].r = q__1.r, y1[i__3].i = q__1.i; /* L110: */ } ++lint1; l1 = lint1 * k1p1 / k2p1; L111: if (n != l2) { goto L113; } i__ = lint2 + kint2; i__2 = i__; q__1.r = x.r - tcos[i__2].r, q__1.i = x.i - tcos[i__2].i; xx.r = q__1.r, xx.i = q__1.i; i__2 = *m; for (i__ = 1; i__ <= i__2; ++i__) { i__3 = i__; i__4 = i__; q__2.r = xx.r * y2[i__4].r - xx.i * y2[i__4].i, q__2.i = xx.r * y2[i__4].i + xx.i * y2[i__4].r; i__5 = i__; q__1.r = q__2.r + w2[i__5].r, q__1.i = q__2.i + w2[i__5].i; y2[i__3].r = q__1.r, y2[i__3].i = q__1.i; /* L112: */ } ++lint2; l2 = lint2 * k1p1 / k3p1; L113: if (n != l3) { goto L115; } i__ = lint3 + kint3; i__2 = i__; q__1.r = x.r - tcos[i__2].r, q__1.i = x.i - tcos[i__2].i; xx.r = q__1.r, xx.i = q__1.i; i__2 = *m; for (i__ = 1; i__ <= i__2; ++i__) { i__3 = i__; i__4 = i__; q__2.r = xx.r * y3[i__4].r - xx.i * y3[i__4].i, q__2.i = xx.r * y3[i__4].i + xx.i * y3[i__4].r; i__5 = i__; q__1.r = q__2.r + w3[i__5].r, q__1.i = q__2.i + w3[i__5].i; y3[i__3].r = q__1.r, y3[i__3].i = q__1.i; /* L114: */ } ++lint3; l3 = lint3 * k1p1 / k4p1; L115: ; } return 0; } /* cmptr3_ */

rf@rufflewind.com

c1b8130916ad3188a3fee34f100a534319c4aebe

5dcae792e2f7fc47aec0b03943a07505c8fd44f7

/Go/5in1row/Menu.h

d82d958b79954a718595c6bda276bcfb025ad414

permissive

Sean-sheep/c2019

35ad7ddd56ba426ff609dfaacec96390a5066746

ff8031280bfa9ef12121dc576a969fff0295ec5b

refs/heads/master

UTF-8

C

h

#if !defined(_Menu_H) #define Menu_H #include "AI.h" #include "Win.h" // #include "Test.h" #include "Const.h" #include "Cover.h" #include "PrintAndChange.h" #include <time.h> #include <conio.h> #include <windows.h> boolean TwoPlayer(unsigned char board[][_Length], int turn, boolean win, struct Location loc, unsigned char cover[][_Length][10], COORD coord, HANDLE handle_out); boolean SinglePlayer(unsigned char board[][_Length], int turn, boolean win, struct Location loc, unsigned char cover[][_Length][10], COORD coord, HANDLE handle_out); #endif

1296997118@qq.com

893decf8ba48e6305f30481b764a81a7f50abb3d

97aa398e9b1d7c70c25a350e8fbaf12e22fb44c8

/hw3-scheduling-simulation-bba753951/resource.c

800a9dd21d9018f7a5da56ce5ec363337718be85

no_license

bba753951/OS_HW

7510d7d9d561231d563ca453c3d020bee067175c

e55d70c8d90c36d0b4d1543fa8a5189e36280262

refs/heads/master

UTF-8

C

c

#include "resource.h" #include <stdio.h> #include <stdlib.h> // #include "scheduling_simulator.h" #include "priorityq.h" #include <ucontext.h> #include "config.h" #include "task_set.h" #include "task.h" task_priority_type cur[TASKS_COUNT]= {0}; // int btn[TASKS_COUNT]={0}; task_const_type val1= { TASK_idle_task, idle_task, 0, }; task_const_type val2= { TASK_idle_task, idle_task, 0, }; status_type get_resource(resource_type id) { status_type result = STATUS_OK; task_type t=0; t=priority_q_front(q); for (int i = 0; i < RESOURCES_COUNT ; i++) { // printf("-----get resource: %u t:%u\n",resource_state[i],t); if(resources_id[i] == id) { if(resource_state[i]!=0) { result = STATUS_ERROR; break; } resource_state[i]=t; // printf("-----get resource2: %u t:%u\n",resource_state[i],t); cur[i]=((task_const_type *)(q->elements + sizeof(task_const_type)))->static_priority; if(cur[i] < resources_priority[i]) { ((task_const_type *)(q->elements + sizeof(task_const_type)))->static_priority=resources_priority[i]; } }; } return result; } status_type release_resource(resource_type id) { status_type result = STATUS_OK; task_type t=0,t1=0,t2=0; task_priority_type tp1=0; int j=0; t=priority_q_front(q); // printf("resource remain:%u\n",q->cur_nr); // printf("********************\n"); int max_index=-1; // if(q->cur_nr>4){ // t=priority_q_Nth(q,1); // printf("1:%u\n",t); // t=priority_q_Nth(q,2); // printf("2:%u\n",t); // t=priority_q_Nth(q,3); // printf("3:%u\n",t); // t=priority_q_Nth(q,4); // printf("4:%u\n",t); // exit(1); // } // int a = q->cur_nr; // for (int j = 0; j < a ; j++){ // printf("remain:%d\n",q->cur_nr); // priority_q_del_min(q, &val1); // printf("terminate id:%u\n",val1.id); // } // printf("---------------------resource1 ---------------------\n"); // for(int i=0;i<TASKS_COUNT;i++){ // printf("task state:%u\n",task_state[i]); // } for (int i = 0; i < RESOURCES_COUNT ; i++) { // printf("-------***--------\n"); // printf("resource state: %u t:%u\n",resource_state[i],t); if(resources_id[i] == id) { if(resource_state[i]!=t) { // printf("release error\n"); return STATUS_ERROR; } resource_state[i]=0; for (int k = 0; k < RESOURCES_COUNT ; k++) { if(resource_state[k]==t && k > max_index) { max_index=k; } } // printf("max_index:%d\n",max_index); if(max_index==-1) { for(j=0; j<TASKS_COUNT; j++) { if(task_const[j].id==t) { break; } } ((task_const_type *)(q->elements + sizeof(task_const_type)))->static_priority=o_priority[j]; } else { ((task_const_type *)(q->elements + sizeof(task_const_type)))->static_priority=resources_priority[max_index]; } // printf("rel p:%u\n",((task_const_type *)(q->elements + sizeof(task_const_type)))->static_priority); // release後可能被preempt priority_q_del_min(q, &val1); t2=val1.id; priority_q_insert(q, &val1); t1=priority_q_front(q); tp1=priority_q_front_priority(q); // printf("---------val1.id:%u\n",val1.id); // printf("---------t1:%u\n",t1); for(j=0; j<TASKS_COUNT; j++) { if(task_const[j].id==val1.id) { break; } } // printf("---------j:%u\n",j); while(t2!=t1) { if(tp1 == val1.static_priority) { priority_q_del_min(q, &val2); priority_q_insert(q, &val2); t1=priority_q_front(q); tp1=priority_q_front_priority(q); } else { task_state[j]=READY; // printf("cur:%u next:%u\n",cur[i],t1); activate_task(t1); t1=priority_q_front(q); } } // printf("---------j:%u\n",j); // printf("---------------------resource2 ---------------------\n"); // for(int i=0;i<TASKS_COUNT;i++){ // printf("task state:%u\n",task_state[i]); // } task_state[j]=RUNNING; }; } // printf("---------------------resource3 ---------------------\n"); // for(int i=0;i<TASKS_COUNT;i++){ // printf("task state:%u\n",task_state[i]); // } return result; }

bba753951@gmail.com

d305f8e3495d17acdb8e910a22552b1d76159128

948f4e13af6b3014582909cc6d762606f2a43365

/testcases/juliet_test_suite/testcases/CWE590_Free_Memory_Not_on_Heap/s04/CWE590_Free_Memory_Not_on_Heap__free_char_static_68b.c

f9b7cb5453042e0b67db1519f0341e5cae74e82a

no_license

junxzm1990/ASAN--

0056a341b8537142e10373c8417f27d7825ad89b

ca96e46422407a55bed4aa551a6ad28ec1eeef4e

refs/heads/master

UTF-8

C

c

/* TEMPLATE GENERATED TESTCASE FILE Filename: CWE590_Free_Memory_Not_on_Heap__free_char_static_68b.c Label Definition File: CWE590_Free_Memory_Not_on_Heap__free.label.xml Template File: sources-sink-68b.tmpl.c */ /* * @description * CWE: 590 Free Memory Not on Heap * BadSource: static Data buffer is declared static on the stack * GoodSource: Allocate memory on the heap * Sink: * BadSink : Print then free data * Flow Variant: 68 Data flow: data passed as a global variable from one function to another in different source files * * */ #include "std_testcase.h" #include <wchar.h> extern char * CWE590_Free_Memory_Not_on_Heap__free_char_static_68_badData; extern char * CWE590_Free_Memory_Not_on_Heap__free_char_static_68_goodG2BData; /* all the sinks are the same, we just want to know where the hit originated if a tool flags one */ #ifndef OMITBAD void CWE590_Free_Memory_Not_on_Heap__free_char_static_68b_badSink() { char * data = CWE590_Free_Memory_Not_on_Heap__free_char_static_68_badData; printLine(data); /* POTENTIAL FLAW: Possibly deallocating memory allocated on the stack */ free(data); } #endif /* OMITBAD */ #ifndef OMITGOOD /* goodG2B uses the GoodSource with the BadSink */ void CWE590_Free_Memory_Not_on_Heap__free_char_static_68b_goodG2BSink() { char * data = CWE590_Free_Memory_Not_on_Heap__free_char_static_68_goodG2BData; printLine(data); /* POTENTIAL FLAW: Possibly deallocating memory allocated on the stack */ free(data); } #endif /* OMITGOOD */

yzhang0701@gmail.com

a1b8d8d5a8d534f5036d1317146a33be2f883120

6c81d3c09d881042ddf8efa1eedf3a218c8ebd0e

/hw2/cread_alt.c

d0a5e87d1a5b6b7c765141b99807b7be064cb899

no_license

elihan27/CS-33-2

99d3a1225c699e35dfe5ba4a48e753af9d04b3b5

3742d399707c24f829c078b70b37a4fe33fa6895

refs/heads/master

UTF-8

C

c

// // main.c // hw2test // Elizabeth Han 004815046 #include <stdio.h> //compiled using -O1 long cread(long *xp) { long zero = 0; long* ZERO = &zero; return *(xp ? xp : ZERO); } /*int main(void) { long x = 3; long *y = &x; long z = cread(y); printf("%li \n", z); long *a; z= cread(a); printf("%li \n", z); return 0; } */

ehan2016@gmail.com

bee3fbe40b500248a0d3776f479bccca9dcf948f

1906c0d69e73d40a450005869e3ac2205381f864

/DUMP/PRO_PlayerCharacter_classes.h

6376c3c39dcb406b7c0ec1d0ae38ca950ef2d954

no_license

xkp95175333/Prospect-Win64-Shipping

cad4b698cb50e48093285e1bf9eedef31ca69918

b3d14230402186be14254a0fdae9ac2fae056fb1

refs/heads/main

UTF-8

C

h

// BlueprintGeneratedClass PRO_PlayerCharacter.PRO_PlayerCharacter_C // Size: 0x8bc (Inherited: 0x6e0) struct APRO_PlayerCharacter_C : AYPlayerCharacter { struct FPointerToUberGraphFrame UberGraphFrame; // 0x6e0(0x08) struct UPlayerDBNOComponent_BP_C* PlayerDBNOComponent_BP; // 0x6e8(0x08) struct UPlayer_InventoryAudioComponent_BP_C* Player_InventoryAudioComponent_BP; // 0x6f0(0x08) struct UTakeDamageBloodDecalComponent_BP_C* TakeDamageBloodDecalComponent_BP; // 0x6f8(0x08) struct UWeaponScopeComponent_BP_C* WeaponScopeComponent_BP; // 0x700(0x08) struct UFlinchesComponent_BP_C* FlinchesComponent_BP; // 0x708(0x08) struct UYPlayerCharacterEffortsComponent_BP_C* YPlayerCharacterEffortsComponent_BP; // 0x710(0x08) struct UHelmetGoggleComponent_BP_C* HelmetGoggleComponent_BP; // 0x718(0x08) struct UTacticalFlashLightComponent_BP_C* TacticalFlashLightComponent_BP; // 0x720(0x08) struct UPlayer_MeleeAttackComponent_BP_C* Player_MeleeAttackComponent_BP; // 0x728(0x08) struct UPlayerCarryingComponent_BP_C* PlayerCarryingComponent_BP; // 0x730(0x08) struct UInteractionAnimComponent_BP_C* InteractionAnimComponent_BP; // 0x738(0x08) struct UYCharacterScopeGlintComponent_BP_C* ScopeGlintComponent_BP; // 0x740(0x08) struct UAudioComponent* SFX_PlayerEfforts_Stamina; // 0x748(0x08) struct UYPlayerTriggerAISenseComponent_BP_C* YPlayerTriggerAISenseComponent_BP; // 0x750(0x08) struct UYPlayerConsumableComponent_BP_C* YPlayerConsumableComponent_BP; // 0x758(0x08) struct UParticleSystemComponent* FX_PlayedEvacuateCharging_PS; // 0x760(0x08) struct UYPingableComponent* YPingable; // 0x768(0x08) struct UPlayerCharacterOutlineComponent_C* PlayerCharacterOutlineComponent; // 0x770(0x08) struct UYPlayerRenderTargetVfxMovementComponent_BP_C* YPlayerRenderTargetVfxMovementComponent_BP; // 0x778(0x08) struct UYPlayerSFXComponent_BP_C* YPlayerSFXComponent_BP; // 0x780(0x08) struct UPlayerCharacterCombatAwarenessComponent_BP_C* PlayerCharacterCombatAwarenessComponent_BP; // 0x788(0x08) struct UYPlayerVFXComponent_BP_C* PRO_PlayerCharacter_VFXComponent; // 0x790(0x08) struct USkeletalMeshComponent* DBNO_FoamMesh_SK; // 0x798(0x08) struct UYPlayerEscapeComponent_BP_C* YPlayerEscapeComponent_BP; // 0x7a0(0x08) struct UYPlayerAnimEvalComponent_BP_C* YPlayerAnimEvalComponent_BP; // 0x7a8(0x08) struct UYAIPerceptionStimuliSourceComp* YAIPerceptionStimuliSourceComp; // 0x7b0(0x08) struct UParticleSystemComponent* Trail; // 0x7b8(0x08) struct UPostProcessComponent* PostProcess; // 0x7c0(0x08) float STE_ChargeVFX_TL_NewTrack_0_E03AF13C4D6D893B0E8DC58C085F8278; // 0x7c8(0x04) enum class ETimelineDirection STE_ChargeVFX_TL__Direction_E03AF13C4D6D893B0E8DC58C085F8278; // 0x7cc(0x01) char pad_7CD[0x3]; // 0x7cd(0x03) struct UTimelineComponent* STE_ChargeVFX_TL; // 0x7d0(0x08) bool IsTagged; // 0x7d8(0x01) char pad_7D9[0x3]; // 0x7d9(0x03) float SlowdownResetTime; // 0x7dc(0x04) float SlowdownMaxSpeed; // 0x7e0(0x04) float SlowdownDuration; // 0x7e4(0x04) float SlowdownImmunityThreshold; // 0x7e8(0x04) bool IsSlowdown; // 0x7ec(0x01) char pad_7ED[0x3]; // 0x7ed(0x03) struct FGuid AddedSlowdown; // 0x7f0(0x10) struct FGuid AttributeModifierMovement; // 0x800(0x10) bool IsHOT; // 0x810(0x01) char pad_811[0x3]; // 0x811(0x03) struct FGuid AddedHOT; // 0x814(0x10) char pad_824[0x4]; // 0x824(0x04) struct AYPlayerController* YPlayerCtrl; // 0x828(0x08) struct UParticleSystemComponent* DamageOverTime_PS; // 0x830(0x08) struct UTextRenderComponent* BugReportingTextComponent; // 0x838(0x08) bool IsCharacterNinja; // 0x840(0x01) bool IsSlowdownImmune; // 0x841(0x01) char pad_842[0x2]; // 0x842(0x02) float SlowdownBuildUp; // 0x844(0x04) float LastDamageTaken; // 0x848(0x04) char pad_84C[0x4]; // 0x84c(0x04) struct FTimerHandle TimerHandleClearSlowdown; // 0x850(0x08) struct UMaterialInstanceDynamic* EoM_Post_MID; // 0x858(0x08) struct AMapAreaLocation_BP_C* LocationConditionChallengeDBNO; // 0x860(0x08) float PvPTargetResetTime; // 0x868(0x04) char pad_86C[0x4]; // 0x86c(0x04) struct AActor* DamageCauser; // 0x870(0x08) int32_t MaxCreditsToDropOnDeathOrRecall; // 0x878(0x04) char pad_87C[0x4]; // 0x87c(0x04) struct FDataTableRowHandle VO_RecallChargeLost; // 0x880(0x10) struct FDataTableRowHandle LeanRowHandle; // 0x890(0x10) struct FVector LastDamageDirection; // 0x8a0(0x0c) struct FVector LastDamageHitLocation; // 0x8ac(0x0c) float PawnCleanUpDelay; // 0x8b8(0x04) struct FYImpactEffectReceiverData GetCustomImpactEffectData(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.GetCustomImpactEffectData // (Event|Public|HasOutParms|BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void GetWeaponFirstPersonMesh(struct UYSkeletalMeshComponentFOV* m_weaponMesh); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.GetWeaponFirstPersonMesh // (Public|HasOutParms|BlueprintCallable|BlueprintEvent|BlueprintPure) // @ game+0x1e02480 void OnLeanDirectionChanged(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.OnLeanDirectionChanged // (Public|BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void PlayCameraShakeOnOwningPlayer(struct UCameraShakeBase* Shake); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.PlayCameraShakeOnOwningPlayer // (Public|BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void OnRep_IsHOT(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.OnRep_IsHOT // (HasDefaults|BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void OnRep_IsSlowdown(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.OnRep_IsSlowdown // (HasDefaults|BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void OnRep_IsTagged(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.OnRep_IsTagged // (BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void OnRep_IsCloaked(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.OnRep_IsCloaked // (BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void GetAnimBlueprint(struct UAnimInstance* AnimInstance); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.GetAnimBlueprint // (Public|HasOutParms|BlueprintCallable|BlueprintEvent|BlueprintPure) // @ game+0x1e02480 void SwitchToThirdPerson(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.SwitchToThirdPerson // (Public|BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void STE_ChargeVFX_TL__FinishedFunc(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.STE_ChargeVFX_TL__FinishedFunc // (BlueprintEvent) // @ game+0x1e02480 void STE_ChargeVFX_TL__UpdateFunc(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.STE_ChargeVFX_TL__UpdateFunc // (BlueprintEvent) // @ game+0x1e02480 void InpActEvt_ToggleNightVision_K2Node_InputActionEvent_2(struct FKey Key); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.InpActEvt_ToggleNightVision_K2Node_InputActionEvent_2 // (BlueprintEvent) // @ game+0x1e02480 void InpActEvt_ToggleLight_K2Node_InputActionEvent_1(struct FKey Key); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.InpActEvt_ToggleLight_K2Node_InputActionEvent_1 // (BlueprintEvent) // @ game+0x1e02480 void ReceiveBeginPlay(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.ReceiveBeginPlay // (Event|Protected|BlueprintEvent) // @ game+0x1e02480 void Server_EH_Trail(float Duration); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.Server_EH_Trail // (BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void Server_EH_Slowdown(bool IsSticky); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.Server_EH_Slowdown // (BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void Server_EH_HOT(bool IsInRange); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.Server_EH_HOT // (BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void CloakStateChanged(bool cloakState); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.CloakStateChanged // (BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void OnEmptyHealth(struct UYHealthComponent* healthComponent, struct AActor* Instigator); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.OnEmptyHealth // (BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void OnEndProne(float HalfHeightAdjust, float ScaledHalfHeightAdjust); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.OnEndProne // (Event|Public|BlueprintEvent) // @ game+0x1e02480 void OnStartProne(float HalfHeightAdjust, float ScaledHalfHeightAdjust); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.OnStartProne // (Event|Public|BlueprintEvent) // @ game+0x1e02480 void UpdatePhysMaterials(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.UpdatePhysMaterials // (BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void BndEvt__m_deathComponent_K2Node_ComponentBoundEvent_5_OnDeathDelegate__DelegateSignature(struct UYCharacterDeathComponent* deathComponent); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.BndEvt__m_deathComponent_K2Node_ComponentBoundEvent_5_OnDeathDelegate__DelegateSignature // (BlueprintEvent) // @ game+0x1e02480 void OnPerkAdded(struct FYPerk perk); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.OnPerkAdded // (HasOutParms|BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void HookUpReportingBugVisualization(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.HookUpReportingBugVisualization // (BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void OnPerkDeactivated(struct FYPerk perk); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.OnPerkDeactivated // (HasOutParms|BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void BndEvt__m_damageComponent_K2Node_ComponentBoundEvent_1_YTakeDamageEvent__DelegateSignature(struct FYDealtDamageData Data); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.BndEvt__m_damageComponent_K2Node_ComponentBoundEvent_1_YTakeDamageEvent__DelegateSignature // (HasOutParms|BlueprintEvent) // @ game+0x1e02480 void OnFinishedDamage(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.OnFinishedDamage // (BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void OnVehicleEnter(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.OnVehicleEnter // (BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void OnVehicleExit(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.OnVehicleExit // (BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void BndEvt__m_stateComponent_K2Node_ComponentBoundEvent_8_YAnyStateChanged__DelegateSignature(enum class EYStateChangeType stateChangeType); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.BndEvt__m_stateComponent_K2Node_ComponentBoundEvent_8_YAnyStateChanged__DelegateSignature // (BlueprintEvent) // @ game+0x1e02480 void DBNO_Activate_Server(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.DBNO_Activate_Server // (BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void DBNO_Deactivate_Server(bool interupted); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.DBNO_Deactivate_Server // (BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void UpdateControllerYawRotation(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.UpdateControllerYawRotation // (BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void StarTrekEvac_FX_Start(float Duration); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.StarTrekEvac_FX_Start // (Net|NetMulticast|BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void StarTrekEvac_FX_Stop(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.StarTrekEvac_FX_Stop // (Net|NetMulticast|BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void OnDeath_Implemented(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.OnDeath_Implemented // (BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void BndEvt__m_interactionComponent_K2Node_ComponentBoundEvent_3_OnPlayerInteractionStarted__DelegateSignature(enum class EYInteractionType interactionType, struct AYPlayerController_Match* interactingPlayer); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.BndEvt__m_interactionComponent_K2Node_ComponentBoundEvent_3_OnPlayerInteractionStarted__DelegateSignature // (BlueprintEvent) // @ game+0x1e02480 void BndEvt__m_characterCustomizationComponent_K2Node_ComponentBoundEvent_4_YOnMeshInitialized__DelegateSignature(); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.BndEvt__m_characterCustomizationComponent_K2Node_ComponentBoundEvent_4_YOnMeshInitialized__DelegateSignature // (BlueprintEvent) // @ game+0x1e02480 void BndEvt__m_armorComponent_K2Node_ComponentBoundEvent_2_YArmorComponentUpdatedSignature__DelegateSignature(struct UYArmorComponent* armorComponent); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.BndEvt__m_armorComponent_K2Node_ComponentBoundEvent_2_YArmorComponentUpdatedSignature__DelegateSignature // (BlueprintEvent) // @ game+0x1e02480 void BP_OnDeath_Event_1(struct UYCharacterDeathComponent* deathComponent); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.BP_OnDeath_Event_1 // (BlueprintCallable|BlueprintEvent) // @ game+0x1e02480 void ExecuteUbergraph_PRO_PlayerCharacter(int32_t EntryPoint); // Function PRO_PlayerCharacter.PRO_PlayerCharacter_C.ExecuteUbergraph_PRO_PlayerCharacter // (Final|UbergraphFunction|HasDefaults) // @ game+0x1e02480 };

68745798+xkp95175333@users.noreply.github.com

d982dd43d5b4af36c08a4f37e4b1553183be2623

65969eb320c536e360abed38cfb15c34d4b2e586

/lee.c

80cd25a6825242bcf6ff21022062ad706cc3e1f3

permissive

essele/roLua

39a593d19a4f520bac72dfbde18821ef095e2c5b

b492912789cac58f4a25e053773e7fc24cb26c21

refs/heads/main

UTF-8

C

c

#include <lua.h> #include <lualib.h> #include <lauxlib.h> #include <lapi.h> #include <lstate.h> #include <lobject.h> #include <lgc.h> #include <stdlib.h> #include <string.h> #include <malloc/malloc.h> #include <lstring.h> static void *lee_alloc (void *ud, void *ptr, size_t osize, size_t nsize) { static size_t running_total = 0; (void)ud; (void)osize; /* not used */ if (nsize == 0) { size_t sz = malloc_size(ptr); running_total -= sz; fprintf(stderr, "freel called on %p (size=%zu) tot=%zu\n", ptr, sz, running_total); free(ptr); return NULL; } else { size_t sz = 0; if (ptr != 0) { sz = malloc_size(ptr); running_total -= sz; } running_total += nsize; fprintf(stderr, "realloc called on %p (%zu -> %zu) tot=%zu\n", ptr, sz, nsize, running_total); return realloc(ptr, nsize); } } int main(int argc, char ** argv) { lua_State *L = lua_newstate(lee_alloc, NULL); fprintf(stderr, " ---- AFTER NEWSTATE ------\n"); TString *s = luaS_new(L, "goto"); uint8_t *p = (uint8_t *)s; fprintf(stderr, "DUMP(%p) ", p); for (int i=0; i < sizeof(TString)+4; i++) { fprintf(stderr, "%02x ", *(p+i)); } fprintf(stderr, "\n"); fprintf(stderr, "%08x\n", s->hash); // exit(0); luaL_openlibs(L); fprintf(stderr, " ---- AFTER OPENLIBS ------\n"); // Push the pointer to function // lua_pushcfunction(L, multiplication); // Get the value on top of the stack // and set as a global, in this case is the function // lua_setglobal(L, "mul"); // Our Lua code, it simply prints a Hello, World message char * code = // "print(collectgarbage('count'));" // "collectgarbage('collect');" // "print(collectgarbage('count'));" // "x=mul(7,8);print(x);f={};f.a=1;f.b=2;print(f.a); print(x.joe);" // "f={};f.a=1;f.b=2;" // "print(f.a);" "for i=1,10 do print('hello') end;" "print(math.pi);" "print(math.floor(4.567));" // "x=nil; f=nil;" // "collectgarbage('collect');" // "print(collectgarbage('count'));" "collectgarbage('collect');" "print(collectgarbage('count'));" "print(math.huge);" "print(math.maxinteger);" "print(string);" "print(string.upper);" "print(string.upper('Lee Essen'));" "print(_VERSION);" "print(_G);" ; // Here we load the string and use lua_pcall for run the code fprintf(stderr, " ---- BEFORE LOADSTRING ------\n"); if (luaL_loadstring(L, code) == LUA_OK) { fprintf(stderr, " ---- AFTER LOADSTRING ------\n"); if (lua_pcall(L, 0, 1, 0) == LUA_OK) { // If it was executed successfuly we // remove the code from the stack lua_pop(L, lua_gettop(L)); } } lua_close(L); return 0; }

lee.essen@nowonline.co.uk

8287a754ebf817ff095a5f39f9d02ec7ff6d239c

c21f66903f03b92c7de9afb75064cb8d42e4c8c5

/Computer Networks Lab: CS15206/Pattern/client.c

371f2a53cbbb37361d69eb0391e5e687d5b4d8c2

no_license

vivek2188/Study

fa1f001eb9fffc6591310d2c6c801ea4e214f1c8

eae76f8046d59baba68783b3bf3ae276ac6ee412

refs/heads/master

Jupyter Notebook

UTF-8

C

c

// Client side code #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <errno.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> int main(void){ int csock; unsigned int len; struct sockaddr_in client; csock = socket(AF_INET,SOCK_STREAM,0); if(csock==-1){ perror("Socket not created\n"); return 1; } client.sin_family = AF_INET; client.sin_port = htons(10000); client.sin_addr.s_addr = INADDR_ANY; bzero(&client.sin_zero,0); len = sizeof(struct sockaddr_in); if(connect(csock,(struct sockaddr *)&client,len)==-1){ perror("Connection failed\n"); return 1; } int k; // Input variables int ch = 1; while(1){ printf("Enter number: "); scanf("%d",&k); send(csock,&k,sizeof(k),0); int n = k * (2*k-1); char ptr[n]; recv(csock,ptr,sizeof(char)*n,0); for(int i=0;i<k;i++){ for(int j=0;j<2*k-1-i;j++) printf("%c",ptr[i*(2*k-1)+j]);; printf("\n"); } printf("Continue? "); scanf("%d",&ch); if(ch!=1){ close(csock); return 0; } } close(csock); return 0; }

tiwarivivekraj17@gmail.com

d72ff3d4ec3ada9988c95d4136098e7c4acf8f6a

3d18a6d10c097db154f96107079e025170442541

/FinalProject/Sources/led_thread.c

a7b4ec20bc74f7eea8f9dc84a9734599a6c33641

no_license

Snazzythat/ecse69_final_project

cc0a7cb9e23fb28c7c837048382b3a597e931815

807a0c53c570a916ca75215b5f166f9009b7c596

refs/heads/master

UTF-8

C

c

//////////////////////////////////////////////////////////////////////////////// // File Name : led_thread.c // Description : program entry // Author : Team 12 // Date : Nov 1st, 2016 //////////////////////////////////////////////////////////////////////////////// // Includes #include "main.h" // Globals osThreadId led_thread_ID; osThreadDef(led_thread, osPriorityNormal, 1,0); /* ** Brief: Starts the LED thread in the OS (from Inactive into the Lifecycle) ** Params: A void pointer to initial arguments, NULL if unused ** Return: None */ void led_thread_init(void *args) { led_thread_ID = osThreadCreate(osThread(led_thread), args); } /* ** Brief: The LED thread function in the OS ** Waits for a signal from the TIM interrupt handler and then ** toggles the on board LEDs ** Params: A void pointer to initial arguments, NULL if unused ** Return: None */ void led_thread(void const *args) { while(1) { osSignalWait(0x00000001, osWaitForever); HAL_GPIO_TogglePin(GPIOD, GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15); } }

yinghan307@gmail.com

3794c2c92e553b27a530f0276dbe213eb9ec7733

0fedaa9e1fd650888f12dd49ef34ead7785ea643

/SRC/applications/BSP_Init.c

8bf3b4e126ea2b81761313a7f54d184b409fa5af

no_license

leomoons/FC_ANO

e6f0ce30289981f7af30ed101d79159bbba7d1de

5207dd2d8eaabe96b9a4cb1be7944ed2a5fdf8cc

refs/heads/main

UTF-8

C

c

/******************** (C) COPYRIGHT 2017 ANO Tech ******************************** * 作者 ：匿名科创 * 官网 ：www.anotc.com * 淘宝 ：anotc.taobao.com * 技术Q群 ：190169595 * 描述 ：飞控初始化 **********************************************************************************/ #include "include.h" #include "Drv_pwm_out.h" #include "Drv_led.h" #include "Drv_spi.h" #include "Drv_icm20602.h" #include "drv_ak8975.h" #include "drv_spl06.h" #include "Drv_w25qxx.h" #include "Drv_i2c_soft.h" #include "Drv_laser.h" #include "Ano_FlightCtrl.h" #include "Drv_adc.h" #include "Drv_heating.h" #include "Ano_RC.h" #include "Ano_Sensor_Basic.h" #include "Drv_UP_Flow.h" #include "param.h" #include "controller.h" #include "motor.h" #include "Ano_DTv7.h" u8 of_init_type; u8 All_Init() { NVIC_PriorityGroupConfig(NVIC_GROUP); //中断优先级组别设置 SysTick_Configuration(); //滴答时钟 Delay_ms(100); //延时 Drv_LED_Init(); //LED功能初始化 Flash_Init(); //板载FLASH芯片驱动初始化 Para_Data_Init(); //参数数据初始化 ParamInit(); // 控制器和扰估计参数初始化 Remote_Control_Init(); PWM_Out_Init(); //初始化电调输出功能 Delay_ms(100); //延时 Drv_SPI2_init(); //spi_2初始化，用于读取飞控板上所有传感器，都用SPI读取 Drv_Icm20602CSPin_Init(); //spi片选初始化 Drv_AK8975CSPin_Init(); //spi片选初始化 Drv_SPL06CSPin_Init(); //spi片选初始化 sens_hd_check.gyro_ok = sens_hd_check.acc_ok = Drv_Icm20602Reg_Init(); //icm陀螺仪加速度计初始化，若初始化成功，则将陀螺仪和加速度的初始化成功标志位赋值 sens_hd_check.mag_ok = 1; //标记罗盘OK sens_hd_check.baro_ok = Drv_Spl0601_Init(); //气压计初始化 Usb_Hid_Init(); //飞控usb接口的hid初始化 Delay_ms(100); //延时 ANO_DT_Init(); Usart2_Init(115200); //串口2初始化，函数参数为波特率 Delay_ms(10); //延时 // Uart4_Init(115200); //首先判断是否连接的是激光模块 // if(!Drv_Laser_Init()) //激光没有有效连接，则配置为光流模式 // Uart4_Init(500000); // Delay_ms(10); //延时 Usart3_Init(115200); //用于和ros端通信 // Delay_ms(10); //延时 // Uart4_Init(19200); //接优像光流 Uart5_Init(115200);//接大功率激光 // MyDelayMs(200); //优像光流初始化 of_init_type = (Drv_OFInit()==0)?0:2; if(of_init_type==2)//优像光流初始化成功 { //大功率激光初始化 Drv_Laser_Init(); } else if(of_init_type==0)//优像光流初始化失败 { Uart4_Init(500000); //接匿名光流 } // Drv_AdcInit(); Delay_ms(100); //延时 All_PID_Init(); //PID初始化 //////////// Drv_GpsPin_Init(); //GPS初始化 串口1 Delay_ms(50); //延时 Drv_HeatingInit(); // Drv_HeatingSet(5); // Sensor_Basic_Init(); // 主控制器初始化 ControllerInit(); // 电调PWM输出初始化 MotorInit(); // ANO_DT_SendString("SYS init OK!"); return (1); } /******************* (C) COPYRIGHT 2014 ANO TECH *****END OF FILE************/

liyuanhao@zju.edu.cn

c6c3bdfecdb996c5a631181b252045ec0128fe41

d317c415b8eda9b2f3d2723e52a669daabc4bb7c

/test/bi_test1.c

9b80d601d8f5a5fadb4187d23c6c5b366869c4d4

no_license

liuguangxi/pe

73fcf8c3ed0d0af2bc6a2555ed7a7561d91565d6

0a1ff3535dbef5856fda3f916011eb3c720c9b2a

refs/heads/master

UTF-8

C

c

#include "pe_test.h" namespace bi_test { SL void bi_test_small() { for (int i = -100; i <= 100; ++i) for (int j = -100; j <= 100; ++j) { bi a(i), b(j); assert(i + j == a + b); assert(i - j == a - b); assert(i * j == a * b); if (j != 0) { assert(i / j == a / b); assert(i % j == a % b); } if (i >= 0 && j >= 0) { assert((i & j) == (a & b)); assert((i ^ j) == (a ^ b)); assert((i | j) == (a | b)); } assert((i > j) == (bool)(a > b)); assert((i < j) == (bool)(a < b)); assert((i == j) == (bool)(a == b)); assert((i >= j) == (bool)(a >= b)); assert((i <= j) == (bool)(a <= b)); } } PE_REGISTER_TEST(&bi_test_small, "bi_test_small", SMALL); #if ENABLE_GMP SL void bi_mul_test_impl(int x, int y) { for (int s1 = -1; s1 <= 1; ++s1) for (int s2 = -1; s2 <= 1; ++s2) for (int id = 0; id < x; ++id) { std::vector<int> A, B; for (int i = 0; i < y; ++i) { A.push_back(rand()); B.push_back(rand()); } string expectedResult; { mpz_class a = s1; mpz_class b = s2; for (auto& iter : A) a *= iter; for (auto& iter : B) b *= iter; mpz_class c = a * b; stringstream ss; ss << c; ss >> expectedResult; } string myResult; { bi a = s1; bi b = s2; for (auto& iter : A) a *= iter; for (auto& iter : B) b *= iter; bi c = a * b; stringstream ss; ss << c; ss >> myResult; } assert(expectedResult == myResult); } } SL void bi_mul_test_medium() { bi_mul_test_impl(1000, 500); } PE_REGISTER_TEST(&bi_mul_test_medium, "bi_mul_test_medium", MEDIUM); SL void bi_mul_test_big() { bi_mul_test_impl(10, 10000); } #if !defined(CONTINUOUS_INTEGRATION_TEST) PE_REGISTER_TEST(&bi_mul_test_big, "bi_mul_test_big", BIG); #endif SL void bi_div_test_medium_impl(int x, int y) { for (int strategy = 0; strategy < 2; ++strategy) for (int s1 = -1; s1 <= 1; ++s1) for (int s2 = -1; s2 <= 1; ++s2) if (s2 != 0) for (int id = 0; id < x; ++id) { std::vector<int> A, B; if (strategy == 0) { for (int i = 0; i < y; ++i) { int t = rand() + 1; A.push_back(t); if (i & 1) { B.push_back(t); } } } else { for (int i = 0; i < y; ++i) { A.push_back(rand() + 1); if (i & 1) { B.push_back(rand() + 1); } } } string expectedResult1; string expectedResult2; { mpz_class a = s1; mpz_class b = s2; for (auto& iter : A) a *= iter; for (auto& iter : B) b *= iter; mpz_class c = a / b; mpz_class d = a % b; stringstream ss; ss << c; ss >> expectedResult1; ss << d; ss >> expectedResult2; } string myResult1; string myResult2; { bi a = s1; bi b = s2; for (auto& iter : A) a *= iter; for (auto& iter : B) b *= iter; bi c, d; tie(c, d) = div(a, b); stringstream ss; ss << c; ss >> myResult1; ss << d; ss >> myResult2; } assert(expectedResult1 == myResult1); assert(expectedResult2 == myResult2); } } SL void bi_div_test_medium() { bi_div_test_medium_impl(100, 500); } #if !defined(CONTINUOUS_INTEGRATION_TEST) PE_REGISTER_TEST(&bi_div_test_medium, "bi_div_test_medium", MEDIUM); #endif SL void bi_div_test_big() { bi_div_test_medium_impl(10, 2000); } #if !defined(CONTINUOUS_INTEGRATION_TEST) PE_REGISTER_TEST(&bi_div_test_big, "bi_div_test_big", BIG); #endif #endif } // namespace bi_test

bailiangsky@gmail.com

add120d8f2e1eda49b0065e6f0ff8ce705bae703

0e69e11163419b8ab50c60a9e4156034ed377365

/Graphs/bfs.c

11058ad1f139fc3501d377d3d03532e9c81d4694

no_license

CodHeK/BaseCodes

c8ad9ab27a7f3cdf7bdecc169c6e5bea9bbc7cf3

db9087f6b8190b6b3542962791917d61ca8a79eb

refs/heads/master

UTF-8

C

c

void bfs(int v) { insert(v); state[v] = waiting while(!not_empty()) { delete(v); print(v); state[v] = visited; for(j=0;j<n;j++) { if(state[j] == initial && graph[v][j] == 1) { insert(j); state[j] = waiting; } } } }

gaganganapathyas@yahoo.in

db61a73a94750946a32fa8812887d06c1a30a7e4

75859787b3eb1fc054b5df82c26bc261421d47e0

/3rdparty/genFiles/RSRP-RangeSL-r12.c

1037dd467dcedec3ad2ad30aa7e7b0c275e4af33

no_license

aa7133/RRC

e118b3d769abff4b0b42d7511530f7b1cc29d09e

955c1ceadebf97d21306f3c083b5f38a24838da4

refs/heads/master

UTF-8

C

c

/* * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) * From ASN.1 module "EUTRA-RRC-Definitions" * found in "../asnFiles/36331-f60-ASNfunctions.asn" * `asn1c -fcompound-names -findirect-choice -fincludes-quoted -fno-include-deps -gen-PER -no-gen-OER -D.` */ #include "RSRP-RangeSL-r12.h" int RSRP_RangeSL_r12_constraint(const asn_TYPE_descriptor_t *td, const void *sptr, asn_app_constraint_failed_f *ctfailcb, void *app_key) { long value; if(!sptr) { ASN__CTFAIL(app_key, td, sptr, "%s: value not given (%s:%d)", td->name, __FILE__, __LINE__); return -1; } value = *(const long *)sptr; if((value >= 0 && value <= 13)) { /* Constraint check succeeded */ return 0; } else { ASN__CTFAIL(app_key, td, sptr, "%s: constraint failed (%s:%d)", td->name, __FILE__, __LINE__); return -1; } } /* * This type is implemented using NativeInteger, * so here we adjust the DEF accordingly. */ asn_per_constraints_t asn_PER_type_RSRP_RangeSL_r12_constr_1 CC_NOTUSED = { { APC_CONSTRAINED, 4, 4, 0, 13 } /* (0..13) */, { APC_UNCONSTRAINED, -1, -1, 0, 0 }, 0, 0 /* No PER value map */ }; static const ber_tlv_tag_t asn_DEF_RSRP_RangeSL_r12_tags_1[] = { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) }; asn_TYPE_descriptor_t asn_DEF_RSRP_RangeSL_r12 = { "RSRP-RangeSL-r12", "RSRP-RangeSL-r12", &asn_OP_NativeInteger, asn_DEF_RSRP_RangeSL_r12_tags_1, sizeof(asn_DEF_RSRP_RangeSL_r12_tags_1) /sizeof(asn_DEF_RSRP_RangeSL_r12_tags_1[0]), /* 1 */ asn_DEF_RSRP_RangeSL_r12_tags_1, /* Same as above */ sizeof(asn_DEF_RSRP_RangeSL_r12_tags_1) /sizeof(asn_DEF_RSRP_RangeSL_r12_tags_1[0]), /* 1 */ { 0, &asn_PER_type_RSRP_RangeSL_r12_constr_1, RSRP_RangeSL_r12_constraint }, 0, 0, /* No members */ 0 /* No specifics */ };

aa7133@att.com

9f2645903d93c6b9e39fbc1e9b4094496f66a432

acd52f69773265a8e46f1c07f5868cdb29b49fdd

/C/15-04/10.h

ab55daa8624b6038666f300686e00f2f0bbab40d

permissive

Numb4r/LPCI

0ebac7d2586c6e55f267aafc9da1b8499285a862

2959863bba81ae67b90c1067f73d039f5fc89e68

refs/heads/master

UTF-8

C

h

int perimetro_retangulo(int lado1,int lado2){ return(2*lado1+2*lado2); } int area_retangulo(int lado1,int lado2){ return lado1*lado2; }

yuri.d.d.faria@gmail.com

5615d1cc69744580b5bcb0019a2a5f34931c71ba

17c87e23e01e074c684619ff0e56706b407f0b23

/omi-1.0.8/pal/sem.h

37bac3318770a130e9e15e9e1786f23beaf6769d

permissive

HuaweiSwitch/OMI

8856be28d0dbe22650dc70635e2749a908802c7d

bca42b3388f0e97d21fd1e872a949fa4032adbff

refs/heads/master

UTF-8

C

h

/* **============================================================================== ** ** Open Management Infrastructure (OMI) ** ** Copyright (c) Microsoft Corporation ** ** 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 ** ** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY ** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED ** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, ** MERCHANTABLITY OR NON-INFRINGEMENT. ** ** See the Apache 2 License for the specific language governing permissions ** and limitations under the License. ** **============================================================================== */ #ifndef _pal_sem_h #define _pal_sem_h #include <nits/base/nits.h> #if defined(PAL_HAVE_POSIX) # include <fcntl.h> # include <sys/stat.h> # include <semaphore.h> # include <time.h> #endif PAL_BEGIN_EXTERNC /* **============================================================================== ** ** Sem - semaphore ** **============================================================================== */ typedef struct _Sem { #if defined(_MSC_VER) HANDLE handle; #else sem_t* sem; #endif } Sem; typedef enum _SemUserAccess { SEM_USER_ACCESS_DEFAULT = 1, SEM_USER_ACCESS_ALLOW_ALL = 2 } SemUserAccess; _Success_(return == 0) int Sem_Init_Injected( _Out_ Sem* self, SemUserAccess userAccess, unsigned int count, NitsCallSite cs); #define Sem_Init(self, userAccess, count) Sem_Init_Injected(self, userAccess, count, NitsHere()) PAL_INLINE void Sem_Destroy( _Inout_ Sem* self) { #if defined(_MSC_VER) CloseHandle(self->handle); #else if (self->sem) { sem_close(self->sem); PAL_Free(self->sem); self->sem = NULL; } #endif } PAL_INLINE int Sem_Wait( _Inout_ Sem* self) { #if defined(_MSC_VER) return WaitForSingleObject(self->handle, INFINITE) == WAIT_OBJECT_0 ? 0 : -1; #else return sem_wait(self->sem) == 0 ? 0 : -1; #endif } #if !defined(CONFIG_HAVE_SEM_TIMEDWAIT) #include <errno.h> #include <pal/sleep.h> int __TimedWaitHelper(sem_t* sem, int milliseconds); #endif PAL_INLINE int Sem_TimedWait( _Inout_ Sem* self, int milliseconds) { #if defined(_MSC_VER) return WaitForSingleObject(self->handle, milliseconds) == WAIT_OBJECT_0 ? 0 : -1; #elif defined(CONFIG_HAVE_SEM_TIMEDWAIT) struct timespec temp = { time(0) + milliseconds / 1000, milliseconds % 1000 * 1000000 }; return sem_timedwait(self->sem, &temp) == 0 ? 0 : -1; #else return __TimedWaitHelper(self->sem, milliseconds); #endif } int Sem_Post( _Inout_ Sem* self, unsigned int count); /* **============================================================================== ** ** NamedSem - named semaphore ** **============================================================================== */ #define NAMEDSEM_FLAG_CREATE 1 #define NAMEDSEM_FLAG_EXCLUSIVE 2 typedef struct _NamedSem { #if defined(_MSC_VER) HANDLE handle; #else sem_t* sem; char semname[PAL_MAX_PATH_SIZE]; #endif } NamedSem; _Return_type_success_(return == 0) int NamedSem_Open_Injected( _Out_ NamedSem* self, SemUserAccess userAccess, unsigned int count, _In_z_ const PAL_Char *name, unsigned long flags, NitsCallSite cs); #define NamedSem_Open(self, userAccess, count, name, flags) NamedSem_Open_Injected(self, userAccess, count, name, flags, NitsHere()) void NamedSem_Close( _Inout_ NamedSem* self); PAL_INLINE int NamedSem_Wait( _Inout_ NamedSem* self) { #if defined(_MSC_VER) return WaitForSingleObject(self->handle, INFINITE) == WAIT_OBJECT_0 ? 0 : -1; #else return sem_wait(self->sem) == 0 ? 0 : -1; #endif } /* * To be called when the semaphore is no longer needed by any user of the semaphore */ PAL_INLINE void NamedSem_Destroy( _Inout_ NamedSem* self) { #if defined(_MSC_VER) #else sem_unlink(self->semname); #endif } PAL_INLINE int NamedSem_TimedWait( _Inout_ NamedSem* self, int milliseconds) { #if defined(_MSC_VER) return WaitForSingleObject(self->handle, milliseconds) == WAIT_OBJECT_0 ? 0 : -1; #elif defined(CONFIG_HAVE_SEM_TIMEDWAIT) struct timespec temp = { time(0) + milliseconds / 1000, milliseconds % 1000 * 1000000 }; return sem_timedwait(self->sem, &temp) == 0 ? 0 : -1; #else return __TimedWaitHelper(self->sem, milliseconds); #endif } int NamedSem_Post( _Inout_ NamedSem* self, unsigned int count); PAL_INLINE int NamedSem_GetValue( _Inout_ NamedSem* self, _Out_ int *value) { #if defined(_MSC_VER) *value = 0; return 0; #else return sem_getvalue(self->sem, value) == 0 ? 0 : -1; #endif } PAL_END_EXTERNC #endif /* _pal_sem_h */

mao58398297

1894214a6f22b1cba984c233f2199ca1cbab8f7d

ab9d533323fedd5f2207f37799361c8f898f4801

/SourceCode/C/day081.c

d61e4f0f8b381e396615471f15e9959e43a80720

no_license

siralomarahmed/100DaysOfCode

f5165de3ca8dceed971af49d27fb148a24b247b8

052976baf7851ba561901064c43a0477bbcce642

refs/heads/master

UTF-8

C

c

/* Author: Ahmed A. M. ALOMAR Date: March 21 - 2020 Description: This program is an example of a program that is going to display value and addresses of pointer. */ #include <stdio.h> #include <stdlib.h> #include <stddef.h> int main(void) { int variable_name = 150; int *pointer_name = NULL; pointer_name = &variable_name; printf("The variable name address is: %p \n", &variable_name); printf("The address of the pointer name is: %p \n", &pointer_name); printf("The value of the pointer name is: %p \n", pointer_name); printf("The value of what pointer name is pointing to is: %d \n", *pointer_name); return 0; }

ahmedamalomar@hotmail.com

cb5d342c2720de427b01970d97981f1231b257a8

f27e3cb90a6bb97c48b92b626fcc2825871d91a7

/0000_base_learn/linux-sys.zh.pdf_learn/process/013_init_daemon/test.c

fe90b4dacf113cdd3e4f2b17e291a59585db4280

no_license

flxshujie799056897/jiuyinzhenjing

0ecf161f9a7f6df86c78a69a60f5c9b8f5134798

caedf00ba6c80cb38996da2bae72d60597e0c202

refs/heads/master

UTF-8

C

c

#include<stdio.h> #include<stdlib.h> #include<pthread.h> int init_daemon(void){ pid_t pid; umask(0);//4 /* clear file mode creation mask */ /* parent exits , child continues */ if((pid = fork()) < 0){//1 printf("error fork()"); return -1; } else if(pid != 0){ printf("error != 0");//正确的分支 exit(0); } setsid();//2 /* become session leader */ /* if(chdir("/")<0){ //3 exit(1); } */ close(1);//5 //close(0); return 0; } int main(){ printf("begin\n"); if(init_daemon() == -1){ exit(0); } while(1){ sleep(1); } printf("end\n"); return 0; } /* 1. 创建子进程，父进程退出 所有工作在子进程中进行 形式上脱离了控制终端 2. 在子进程中创建新会话 setsid()函数 使子进程完全独立出来，脱离控制 3. 改变当前目录为根目录 chdir()函数 防止占用可卸载的文件系统 也可以换成其它路径 4. 重设文件权限掩码 umask()函数 防止继承的文件创建屏蔽字拒绝某些权限 增加守护进程灵活性 5. 关闭文件描述符 继承的打开文件不会用到，浪费系统资源，无法卸载 6. 开始执行守护进程核心工作 7. 守护进程退出处理 */

847479962@qq.com

6492c0a493cd5dac7cdc841ccd7b36ea2bd73af5

58dec800343af173deaa707a858526bbf4cc2570

/src/create_dir_wrappers.c

a72fa363b1e11c9cd4c28ed2a015837c360ecc3a

no_license

JustusAdam/idris-posix

ed9f36bdecd0e010b5b20976d90ce07b3bd58e88

d4d8e917b5feb7c23a877e404343df7d72b714bc

refs/heads/master

UTF-8

C

c

#include <sys/stat.h> int idris_create_dir(const char* filename) { // For now we simply assign all the permissions // More fine grained control may be subject of future work return mkdir(filename, S_IRWXO | S_IRWXG | S_IRWXU); }

dev@justus.science

ad3b0e0a14086f960cb07c404e3e2d1b215a5e61

253dc4e0b1ee631e248021b8c80386add36d4128

/src/microkernel/src/mbedtls/bn_mul.h

d5cf1c4f2dbb11e83d8e57c78435f74b4a7bb3b6

no_license

wesley-hk/EZIOT-SDK

440265b41247b4d95060a4e84ba30f9edf009ea6

f1dbabd3fa522e556945559e08afcb32dcbd2b0a

refs/heads/master

UTF-8

C

h

/** * \file bn_mul.h * * \brief Multi-precision integer library * * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved * SPDX-License-Identifier: Apache-2.0 * * 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. * * This file is part of mbed TLS (https://tls.mbed.org) */ /* * Multiply source vector [s] with b, add result * to destination vector [d] and set carry c. * * Currently supports: * * . IA-32 (386+) . AMD64 / EM64T * . IA-32 (SSE2) . Motorola 68000 * . PowerPC, 32-bit . MicroBlaze * . PowerPC, 64-bit . TriCore * . SPARC v8 . ARM v3+ * . Alpha . MIPS32 * . C, longlong . C, generic */ #ifndef BSCOMPTLS_BN_MUL_H #define BSCOMPTLS_BN_MUL_H #include "bignum.h" #if defined(BSCOMPTLS_HAVE_ASM) #ifndef asm #define asm __asm #endif /* armcc5 --gnu defines __GNUC__ but doesn't support GNU's extended asm */ #if defined(__GNUC__) && \ ( !defined(__ARMCC_VERSION) || __ARMCC_VERSION >= 6000000 ) #if defined(__i386__) #define MULADDC_INIT \ asm( \ "movl %%ebx, %0 \n\t" \ "movl %5, %%esi \n\t" \ "movl %6, %%edi \n\t" \ "movl %7, %%ecx \n\t" \ "movl %8, %%ebx \n\t" #define MULADDC_CORE \ "lodsl \n\t" \ "mull %%ebx \n\t" \ "addl %%ecx, %%eax \n\t" \ "adcl $0, %%edx \n\t" \ "addl (%%edi), %%eax \n\t" \ "adcl $0, %%edx \n\t" \ "movl %%edx, %%ecx \n\t" \ "stosl \n\t" #if defined(BSCOMPTLS_HAVE_SSE2) #define MULADDC_HUIT \ "movd %%ecx, %%mm1 \n\t" \ "movd %%ebx, %%mm0 \n\t" \ "movd (%%edi), %%mm3 \n\t" \ "paddq %%mm3, %%mm1 \n\t" \ "movd (%%esi), %%mm2 \n\t" \ "pmuludq %%mm0, %%mm2 \n\t" \ "movd 4(%%esi), %%mm4 \n\t" \ "pmuludq %%mm0, %%mm4 \n\t" \ "movd 8(%%esi), %%mm6 \n\t" \ "pmuludq %%mm0, %%mm6 \n\t" \ "movd 12(%%esi), %%mm7 \n\t" \ "pmuludq %%mm0, %%mm7 \n\t" \ "paddq %%mm2, %%mm1 \n\t" \ "movd 4(%%edi), %%mm3 \n\t" \ "paddq %%mm4, %%mm3 \n\t" \ "movd 8(%%edi), %%mm5 \n\t" \ "paddq %%mm6, %%mm5 \n\t" \ "movd 12(%%edi), %%mm4 \n\t" \ "paddq %%mm4, %%mm7 \n\t" \ "movd %%mm1, (%%edi) \n\t" \ "movd 16(%%esi), %%mm2 \n\t" \ "pmuludq %%mm0, %%mm2 \n\t" \ "psrlq $32, %%mm1 \n\t" \ "movd 20(%%esi), %%mm4 \n\t" \ "pmuludq %%mm0, %%mm4 \n\t" \ "paddq %%mm3, %%mm1 \n\t" \ "movd 24(%%esi), %%mm6 \n\t" \ "pmuludq %%mm0, %%mm6 \n\t" \ "movd %%mm1, 4(%%edi) \n\t" \ "psrlq $32, %%mm1 \n\t" \ "movd 28(%%esi), %%mm3 \n\t" \ "pmuludq %%mm0, %%mm3 \n\t" \ "paddq %%mm5, %%mm1 \n\t" \ "movd 16(%%edi), %%mm5 \n\t" \ "paddq %%mm5, %%mm2 \n\t" \ "movd %%mm1, 8(%%edi) \n\t" \ "psrlq $32, %%mm1 \n\t" \ "paddq %%mm7, %%mm1 \n\t" \ "movd 20(%%edi), %%mm5 \n\t" \ "paddq %%mm5, %%mm4 \n\t" \ "movd %%mm1, 12(%%edi) \n\t" \ "psrlq $32, %%mm1 \n\t" \ "paddq %%mm2, %%mm1 \n\t" \ "movd 24(%%edi), %%mm5 \n\t" \ "paddq %%mm5, %%mm6 \n\t" \ "movd %%mm1, 16(%%edi) \n\t" \ "psrlq $32, %%mm1 \n\t" \ "paddq %%mm4, %%mm1 \n\t" \ "movd 28(%%edi), %%mm5 \n\t" \ "paddq %%mm5, %%mm3 \n\t" \ "movd %%mm1, 20(%%edi) \n\t" \ "psrlq $32, %%mm1 \n\t" \ "paddq %%mm6, %%mm1 \n\t" \ "movd %%mm1, 24(%%edi) \n\t" \ "psrlq $32, %%mm1 \n\t" \ "paddq %%mm3, %%mm1 \n\t" \ "movd %%mm1, 28(%%edi) \n\t" \ "addl $32, %%edi \n\t" \ "addl $32, %%esi \n\t" \ "psrlq $32, %%mm1 \n\t" \ "movd %%mm1, %%ecx \n\t" #define MULADDC_STOP \ "emms \n\t" \ "movl %4, %%ebx \n\t" \ "movl %%ecx, %1 \n\t" \ "movl %%edi, %2 \n\t" \ "movl %%esi, %3 \n\t" \ : "=m" (t), "=m" (c), "=m" (d), "=m" (s) \ : "m" (t), "m" (s), "m" (d), "m" (c), "m" (b) \ : "eax", "ecx", "edx", "esi", "edi" \ ); #else #define MULADDC_STOP \ "movl %4, %%ebx \n\t" \ "movl %%ecx, %1 \n\t" \ "movl %%edi, %2 \n\t" \ "movl %%esi, %3 \n\t" \ : "=m" (t), "=m" (c), "=m" (d), "=m" (s) \ : "m" (t), "m" (s), "m" (d), "m" (c), "m" (b) \ : "eax", "ecx", "edx", "esi", "edi" \ ); #endif /* SSE2 */ #endif /* i386 */ #if defined(__amd64__) || defined (__x86_64__) #define MULADDC_INIT \ asm( \ "xorq %%r8, %%r8 \n\t" #define MULADDC_CORE \ "movq (%%rsi), %%rax \n\t" \ "mulq %%rbx \n\t" \ "addq $8, %%rsi \n\t" \ "addq %%rcx, %%rax \n\t" \ "movq %%r8, %%rcx \n\t" \ "adcq $0, %%rdx \n\t" \ "nop \n\t" \ "addq %%rax, (%%rdi) \n\t" \ "adcq %%rdx, %%rcx \n\t" \ "addq $8, %%rdi \n\t" #define MULADDC_STOP \ : "+c" (c), "+D" (d), "+S" (s) \ : "b" (b) \ : "rax", "rdx", "r8" \ ); #endif /* AMD64 */ #if defined(__mc68020__) || defined(__mcpu32__) #define MULADDC_INIT \ asm( \ "movl %3, %%a2 \n\t" \ "movl %4, %%a3 \n\t" \ "movl %5, %%d3 \n\t" \ "movl %6, %%d2 \n\t" \ "moveq #0, %%d0 \n\t" #define MULADDC_CORE \ "movel %%a2@+, %%d1 \n\t" \ "mulul %%d2, %%d4:%%d1 \n\t" \ "addl %%d3, %%d1 \n\t" \ "addxl %%d0, %%d4 \n\t" \ "moveq #0, %%d3 \n\t" \ "addl %%d1, %%a3@+ \n\t" \ "addxl %%d4, %%d3 \n\t" #define MULADDC_STOP \ "movl %%d3, %0 \n\t" \ "movl %%a3, %1 \n\t" \ "movl %%a2, %2 \n\t" \ : "=m" (c), "=m" (d), "=m" (s) \ : "m" (s), "m" (d), "m" (c), "m" (b) \ : "d0", "d1", "d2", "d3", "d4", "a2", "a3" \ ); #define MULADDC_HUIT \ "movel %%a2@+, %%d1 \n\t" \ "mulul %%d2, %%d4:%%d1 \n\t" \ "addxl %%d3, %%d1 \n\t" \ "addxl %%d0, %%d4 \n\t" \ "addl %%d1, %%a3@+ \n\t" \ "movel %%a2@+, %%d1 \n\t" \ "mulul %%d2, %%d3:%%d1 \n\t" \ "addxl %%d4, %%d1 \n\t" \ "addxl %%d0, %%d3 \n\t" \ "addl %%d1, %%a3@+ \n\t" \ "movel %%a2@+, %%d1 \n\t" \ "mulul %%d2, %%d4:%%d1 \n\t" \ "addxl %%d3, %%d1 \n\t" \ "addxl %%d0, %%d4 \n\t" \ "addl %%d1, %%a3@+ \n\t" \ "movel %%a2@+, %%d1 \n\t" \ "mulul %%d2, %%d3:%%d1 \n\t" \ "addxl %%d4, %%d1 \n\t" \ "addxl %%d0, %%d3 \n\t" \ "addl %%d1, %%a3@+ \n\t" \ "movel %%a2@+, %%d1 \n\t" \ "mulul %%d2, %%d4:%%d1 \n\t" \ "addxl %%d3, %%d1 \n\t" \ "addxl %%d0, %%d4 \n\t" \ "addl %%d1, %%a3@+ \n\t" \ "movel %%a2@+, %%d1 \n\t" \ "mulul %%d2, %%d3:%%d1 \n\t" \ "addxl %%d4, %%d1 \n\t" \ "addxl %%d0, %%d3 \n\t" \ "addl %%d1, %%a3@+ \n\t" \ "movel %%a2@+, %%d1 \n\t" \ "mulul %%d2, %%d4:%%d1 \n\t" \ "addxl %%d3, %%d1 \n\t" \ "addxl %%d0, %%d4 \n\t" \ "addl %%d1, %%a3@+ \n\t" \ "movel %%a2@+, %%d1 \n\t" \ "mulul %%d2, %%d3:%%d1 \n\t" \ "addxl %%d4, %%d1 \n\t" \ "addxl %%d0, %%d3 \n\t" \ "addl %%d1, %%a3@+ \n\t" \ "addxl %%d0, %%d3 \n\t" #endif /* MC68000 */ #if defined(__powerpc64__) || defined(__ppc64__) #if defined(__MACH__) && defined(__APPLE__) #define MULADDC_INIT \ asm( \ "ld r3, %3 \n\t" \ "ld r4, %4 \n\t" \ "ld r5, %5 \n\t" \ "ld r6, %6 \n\t" \ "addi r3, r3, -8 \n\t" \ "addi r4, r4, -8 \n\t" \ "addic r5, r5, 0 \n\t" #define MULADDC_CORE \ "ldu r7, 8(r3) \n\t" \ "mulld r8, r7, r6 \n\t" \ "mulhdu r9, r7, r6 \n\t" \ "adde r8, r8, r5 \n\t" \ "ld r7, 8(r4) \n\t" \ "addze r5, r9 \n\t" \ "addc r8, r8, r7 \n\t" \ "stdu r8, 8(r4) \n\t" #define MULADDC_STOP \ "addze r5, r5 \n\t" \ "addi r4, r4, 8 \n\t" \ "addi r3, r3, 8 \n\t" \ "std r5, %0 \n\t" \ "std r4, %1 \n\t" \ "std r3, %2 \n\t" \ : "=m" (c), "=m" (d), "=m" (s) \ : "m" (s), "m" (d), "m" (c), "m" (b) \ : "r3", "r4", "r5", "r6", "r7", "r8", "r9" \ ); #else /* __MACH__ && __APPLE__ */ #define MULADDC_INIT \ asm( \ "ld %%r3, %3 \n\t" \ "ld %%r4, %4 \n\t" \ "ld %%r5, %5 \n\t" \ "ld %%r6, %6 \n\t" \ "addi %%r3, %%r3, -8 \n\t" \ "addi %%r4, %%r4, -8 \n\t" \ "addic %%r5, %%r5, 0 \n\t" #define MULADDC_CORE \ "ldu %%r7, 8(%%r3) \n\t" \ "mulld %%r8, %%r7, %%r6 \n\t" \ "mulhdu %%r9, %%r7, %%r6 \n\t" \ "adde %%r8, %%r8, %%r5 \n\t" \ "ld %%r7, 8(%%r4) \n\t" \ "addze %%r5, %%r9 \n\t" \ "addc %%r8, %%r8, %%r7 \n\t" \ "stdu %%r8, 8(%%r4) \n\t" #define MULADDC_STOP \ "addze %%r5, %%r5 \n\t" \ "addi %%r4, %%r4, 8 \n\t" \ "addi %%r3, %%r3, 8 \n\t" \ "std %%r5, %0 \n\t" \ "std %%r4, %1 \n\t" \ "std %%r3, %2 \n\t" \ : "=m" (c), "=m" (d), "=m" (s) \ : "m" (s), "m" (d), "m" (c), "m" (b) \ : "r3", "r4", "r5", "r6", "r7", "r8", "r9" \ ); #endif /* __MACH__ && __APPLE__ */ #elif defined(__powerpc__) || defined(__ppc__) /* end PPC64/begin PPC32 */ #if defined(__MACH__) && defined(__APPLE__) #define MULADDC_INIT \ asm( \ "lwz r3, %3 \n\t" \ "lwz r4, %4 \n\t" \ "lwz r5, %5 \n\t" \ "lwz r6, %6 \n\t" \ "addi r3, r3, -4 \n\t" \ "addi r4, r4, -4 \n\t" \ "addic r5, r5, 0 \n\t" #define MULADDC_CORE \ "lwzu r7, 4(r3) \n\t" \ "mullw r8, r7, r6 \n\t" \ "mulhwu r9, r7, r6 \n\t" \ "adde r8, r8, r5 \n\t" \ "lwz r7, 4(r4) \n\t" \ "addze r5, r9 \n\t" \ "addc r8, r8, r7 \n\t" \ "stwu r8, 4(r4) \n\t" #define MULADDC_STOP \ "addze r5, r5 \n\t" \ "addi r4, r4, 4 \n\t" \ "addi r3, r3, 4 \n\t" \ "stw r5, %0 \n\t" \ "stw r4, %1 \n\t" \ "stw r3, %2 \n\t" \ : "=m" (c), "=m" (d), "=m" (s) \ : "m" (s), "m" (d), "m" (c), "m" (b) \ : "r3", "r4", "r5", "r6", "r7", "r8", "r9" \ ); #else /* __MACH__ && __APPLE__ */ #define MULADDC_INIT \ asm( \ "lwz %%r3, %3 \n\t" \ "lwz %%r4, %4 \n\t" \ "lwz %%r5, %5 \n\t" \ "lwz %%r6, %6 \n\t" \ "addi %%r3, %%r3, -4 \n\t" \ "addi %%r4, %%r4, -4 \n\t" \ "addic %%r5, %%r5, 0 \n\t" #define MULADDC_CORE \ "lwzu %%r7, 4(%%r3) \n\t" \ "mullw %%r8, %%r7, %%r6 \n\t" \ "mulhwu %%r9, %%r7, %%r6 \n\t" \ "adde %%r8, %%r8, %%r5 \n\t" \ "lwz %%r7, 4(%%r4) \n\t" \ "addze %%r5, %%r9 \n\t" \ "addc %%r8, %%r8, %%r7 \n\t" \ "stwu %%r8, 4(%%r4) \n\t" #define MULADDC_STOP \ "addze %%r5, %%r5 \n\t" \ "addi %%r4, %%r4, 4 \n\t" \ "addi %%r3, %%r3, 4 \n\t" \ "stw %%r5, %0 \n\t" \ "stw %%r4, %1 \n\t" \ "stw %%r3, %2 \n\t" \ : "=m" (c), "=m" (d), "=m" (s) \ : "m" (s), "m" (d), "m" (c), "m" (b) \ : "r3", "r4", "r5", "r6", "r7", "r8", "r9" \ ); #endif /* __MACH__ && __APPLE__ */ #endif /* PPC32 */ /* * The Sparc(64) assembly is reported to be broken. * Disable it for now, until we're able to fix it. */ #if 0 && defined(__sparc__) #if defined(__sparc64__) #define MULADDC_INIT \ asm( \ "ldx %3, %%o0 \n\t" \ "ldx %4, %%o1 \n\t" \ "ld %5, %%o2 \n\t" \ "ld %6, %%o3 \n\t" #define MULADDC_CORE \ "ld [%%o0], %%o4 \n\t" \ "inc 4, %%o0 \n\t" \ "ld [%%o1], %%o5 \n\t" \ "umul %%o3, %%o4, %%o4 \n\t" \ "addcc %%o4, %%o2, %%o4 \n\t" \ "rd %%y, %%g1 \n\t" \ "addx %%g1, 0, %%g1 \n\t" \ "addcc %%o4, %%o5, %%o4 \n\t" \ "st %%o4, [%%o1] \n\t" \ "addx %%g1, 0, %%o2 \n\t" \ "inc 4, %%o1 \n\t" #define MULADDC_STOP \ "st %%o2, %0 \n\t" \ "stx %%o1, %1 \n\t" \ "stx %%o0, %2 \n\t" \ : "=m" (c), "=m" (d), "=m" (s) \ : "m" (s), "m" (d), "m" (c), "m" (b) \ : "g1", "o0", "o1", "o2", "o3", "o4", \ "o5" \ ); #else /* __sparc64__ */ #define MULADDC_INIT \ asm( \ "ld %3, %%o0 \n\t" \ "ld %4, %%o1 \n\t" \ "ld %5, %%o2 \n\t" \ "ld %6, %%o3 \n\t" #define MULADDC_CORE \ "ld [%%o0], %%o4 \n\t" \ "inc 4, %%o0 \n\t" \ "ld [%%o1], %%o5 \n\t" \ "umul %%o3, %%o4, %%o4 \n\t" \ "addcc %%o4, %%o2, %%o4 \n\t" \ "rd %%y, %%g1 \n\t" \ "addx %%g1, 0, %%g1 \n\t" \ "addcc %%o4, %%o5, %%o4 \n\t" \ "st %%o4, [%%o1] \n\t" \ "addx %%g1, 0, %%o2 \n\t" \ "inc 4, %%o1 \n\t" #define MULADDC_STOP \ "st %%o2, %0 \n\t" \ "st %%o1, %1 \n\t" \ "st %%o0, %2 \n\t" \ : "=m" (c), "=m" (d), "=m" (s) \ : "m" (s), "m" (d), "m" (c), "m" (b) \ : "g1", "o0", "o1", "o2", "o3", "o4", \ "o5" \ ); #endif /* __sparc64__ */ #endif /* __sparc__ */ #if defined(__microblaze__) || defined(microblaze) #define MULADDC_INIT \ asm( \ "lwi r3, %3 \n\t" \ "lwi r4, %4 \n\t" \ "lwi r5, %5 \n\t" \ "lwi r6, %6 \n\t" \ "andi r7, r6, 0xffff \n\t" \ "bsrli r6, r6, 16 \n\t" #define MULADDC_CORE \ "lhui r8, r3, 0 \n\t" \ "addi r3, r3, 2 \n\t" \ "lhui r9, r3, 0 \n\t" \ "addi r3, r3, 2 \n\t" \ "mul r10, r9, r6 \n\t" \ "mul r11, r8, r7 \n\t" \ "mul r12, r9, r7 \n\t" \ "mul r13, r8, r6 \n\t" \ "bsrli r8, r10, 16 \n\t" \ "bsrli r9, r11, 16 \n\t" \ "add r13, r13, r8 \n\t" \ "add r13, r13, r9 \n\t" \ "bslli r10, r10, 16 \n\t" \ "bslli r11, r11, 16 \n\t" \ "add r12, r12, r10 \n\t" \ "addc r13, r13, r0 \n\t" \ "add r12, r12, r11 \n\t" \ "addc r13, r13, r0 \n\t" \ "lwi r10, r4, 0 \n\t" \ "add r12, r12, r10 \n\t" \ "addc r13, r13, r0 \n\t" \ "add r12, r12, r5 \n\t" \ "addc r5, r13, r0 \n\t" \ "swi r12, r4, 0 \n\t" \ "addi r4, r4, 4 \n\t" #define MULADDC_STOP \ "swi r5, %0 \n\t" \ "swi r4, %1 \n\t" \ "swi r3, %2 \n\t" \ : "=m" (c), "=m" (d), "=m" (s) \ : "m" (s), "m" (d), "m" (c), "m" (b) \ : "r3", "r4" "r5", "r6", "r7", "r8", \ "r9", "r10", "r11", "r12", "r13" \ ); #endif /* MicroBlaze */ #if defined(__tricore__) #define MULADDC_INIT \ asm( \ "ld.a %%a2, %3 \n\t" \ "ld.a %%a3, %4 \n\t" \ "ld.w %%d4, %5 \n\t" \ "ld.w %%d1, %6 \n\t" \ "xor %%d5, %%d5 \n\t" #define MULADDC_CORE \ "ld.w %%d0, [%%a2+] \n\t" \ "madd.u %%e2, %%e4, %%d0, %%d1 \n\t" \ "ld.w %%d0, [%%a3] \n\t" \ "addx %%d2, %%d2, %%d0 \n\t" \ "addc %%d3, %%d3, 0 \n\t" \ "mov %%d4, %%d3 \n\t" \ "st.w [%%a3+], %%d2 \n\t" #define MULADDC_STOP \ "st.w %0, %%d4 \n\t" \ "st.a %1, %%a3 \n\t" \ "st.a %2, %%a2 \n\t" \ : "=m" (c), "=m" (d), "=m" (s) \ : "m" (s), "m" (d), "m" (c), "m" (b) \ : "d0", "d1", "e2", "d4", "a2", "a3" \ ); #endif /* TriCore */ /* * gcc -O0 by default uses r7 for the frame pointer, so it complains about our * use of r7 below, unless -fomit-frame-pointer is passed. Unfortunately, * passing that option is not easy when building with yotta. * * On the other hand, -fomit-frame-pointer is implied by any -Ox options with * x !=0, which we can detect using __OPTIMIZE__ (which is also defined by * clang and armcc5 under the same conditions). * * So, only use the optimized assembly below for optimized build, which avoids * the build error and is pretty reasonable anyway. */ #if defined(__GNUC__) && !defined(__OPTIMIZE__) #define MULADDC_CANNOT_USE_R7 #endif #if defined(__arm__) && !defined(MULADDC_CANNOT_USE_R7) #if defined(__thumb__) && !defined(__thumb2__) #define MULADDC_INIT \ asm( \ "ldr r0, %3 \n\t" \ "ldr r1, %4 \n\t" \ "ldr r2, %5 \n\t" \ "ldr r3, %6 \n\t" \ "lsr r7, r3, #16 \n\t" \ "mov r9, r7 \n\t" \ "lsl r7, r3, #16 \n\t" \ "lsr r7, r7, #16 \n\t" \ "mov r8, r7 \n\t" #define MULADDC_CORE \ "ldmia r0!, {r6} \n\t" \ "lsr r7, r6, #16 \n\t" \ "lsl r6, r6, #16 \n\t" \ "lsr r6, r6, #16 \n\t" \ "mov r4, r8 \n\t" \ "mul r4, r6 \n\t" \ "mov r3, r9 \n\t" \ "mul r6, r3 \n\t" \ "mov r5, r9 \n\t" \ "mul r5, r7 \n\t" \ "mov r3, r8 \n\t" \ "mul r7, r3 \n\t" \ "lsr r3, r6, #16 \n\t" \ "add r5, r5, r3 \n\t" \ "lsr r3, r7, #16 \n\t" \ "add r5, r5, r3 \n\t" \ "add r4, r4, r2 \n\t" \ "mov r2, #0 \n\t" \ "adc r5, r2 \n\t" \ "lsl r3, r6, #16 \n\t" \ "add r4, r4, r3 \n\t" \ "adc r5, r2 \n\t" \ "lsl r3, r7, #16 \n\t" \ "add r4, r4, r3 \n\t" \ "adc r5, r2 \n\t" \ "ldr r3, [r1] \n\t" \ "add r4, r4, r3 \n\t" \ "adc r2, r5 \n\t" \ "stmia r1!, {r4} \n\t" #define MULADDC_STOP \ "str r2, %0 \n\t" \ "str r1, %1 \n\t" \ "str r0, %2 \n\t" \ : "=m" (c), "=m" (d), "=m" (s) \ : "m" (s), "m" (d), "m" (c), "m" (b) \ : "r0", "r1", "r2", "r3", "r4", "r5", \ "r6", "r7", "r8", "r9", "cc" \ ); #else #define MULADDC_INIT \ asm( \ "ldr r0, %3 \n\t" \ "ldr r1, %4 \n\t" \ "ldr r2, %5 \n\t" \ "ldr r3, %6 \n\t" #define MULADDC_CORE \ "ldr r4, [r0], #4 \n\t" \ "mov r5, #0 \n\t" \ "ldr r6, [r1] \n\t" \ "umlal r2, r5, r3, r4 \n\t" \ "adds r7, r6, r2 \n\t" \ "adc r2, r5, #0 \n\t" \ "str r7, [r1], #4 \n\t" #define MULADDC_STOP \ "str r2, %0 \n\t" \ "str r1, %1 \n\t" \ "str r0, %2 \n\t" \ : "=m" (c), "=m" (d), "=m" (s) \ : "m" (s), "m" (d), "m" (c), "m" (b) \ : "r0", "r1", "r2", "r3", "r4", "r5", \ "r6", "r7", "cc" \ ); #endif /* Thumb */ #endif /* ARMv3 */ #if defined(__alpha__) #define MULADDC_INIT \ asm( \ "ldq $1, %3 \n\t" \ "ldq $2, %4 \n\t" \ "ldq $3, %5 \n\t" \ "ldq $4, %6 \n\t" #define MULADDC_CORE \ "ldq $6, 0($1) \n\t" \ "addq $1, 8, $1 \n\t" \ "mulq $6, $4, $7 \n\t" \ "umulh $6, $4, $6 \n\t" \ "addq $7, $3, $7 \n\t" \ "cmpult $7, $3, $3 \n\t" \ "ldq $5, 0($2) \n\t" \ "addq $7, $5, $7 \n\t" \ "cmpult $7, $5, $5 \n\t" \ "stq $7, 0($2) \n\t" \ "addq $2, 8, $2 \n\t" \ "addq $6, $3, $3 \n\t" \ "addq $5, $3, $3 \n\t" #define MULADDC_STOP \ "stq $3, %0 \n\t" \ "stq $2, %1 \n\t" \ "stq $1, %2 \n\t" \ : "=m" (c), "=m" (d), "=m" (s) \ : "m" (s), "m" (d), "m" (c), "m" (b) \ : "$1", "$2", "$3", "$4", "$5", "$6", "$7" \ ); #endif /* Alpha */ #if defined(__mips__) && !defined(__mips64) #define MULADDC_INIT \ asm( \ "lw $10, %3 \n\t" \ "lw $11, %4 \n\t" \ "lw $12, %5 \n\t" \ "lw $13, %6 \n\t" #define MULADDC_CORE \ "lw $14, 0($10) \n\t" \ "multu $13, $14 \n\t" \ "addi $10, $10, 4 \n\t" \ "mflo $14 \n\t" \ "mfhi $9 \n\t" \ "addu $14, $12, $14 \n\t" \ "lw $15, 0($11) \n\t" \ "sltu $12, $14, $12 \n\t" \ "addu $15, $14, $15 \n\t" \ "sltu $14, $15, $14 \n\t" \ "addu $12, $12, $9 \n\t" \ "sw $15, 0($11) \n\t" \ "addu $12, $12, $14 \n\t" \ "addi $11, $11, 4 \n\t" #define MULADDC_STOP \ "sw $12, %0 \n\t" \ "sw $11, %1 \n\t" \ "sw $10, %2 \n\t" \ : "=m" (c), "=m" (d), "=m" (s) \ : "m" (s), "m" (d), "m" (c), "m" (b) \ : "$9", "$10", "$11", "$12", "$13", "$14", "$15" \ ); #endif /* MIPS */ #endif /* GNUC */ #if (defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__) #define MULADDC_INIT \ __asm mov esi, s \ __asm mov edi, d \ __asm mov ecx, c \ __asm mov ebx, b #define MULADDC_CORE \ __asm lodsd \ __asm mul ebx \ __asm add eax, ecx \ __asm adc edx, 0 \ __asm add eax, [edi] \ __asm adc edx, 0 \ __asm mov ecx, edx \ __asm stosd #if defined(BSCOMPTLS_HAVE_SSE2) #define EMIT __asm _emit #define MULADDC_HUIT \ EMIT 0x0F EMIT 0x6E EMIT 0xC9 \ EMIT 0x0F EMIT 0x6E EMIT 0xC3 \ EMIT 0x0F EMIT 0x6E EMIT 0x1F \ EMIT 0x0F EMIT 0xD4 EMIT 0xCB \ EMIT 0x0F EMIT 0x6E EMIT 0x16 \ EMIT 0x0F EMIT 0xF4 EMIT 0xD0 \ EMIT 0x0F EMIT 0x6E EMIT 0x66 EMIT 0x04 \ EMIT 0x0F EMIT 0xF4 EMIT 0xE0 \ EMIT 0x0F EMIT 0x6E EMIT 0x76 EMIT 0x08 \ EMIT 0x0F EMIT 0xF4 EMIT 0xF0 \ EMIT 0x0F EMIT 0x6E EMIT 0x7E EMIT 0x0C \ EMIT 0x0F EMIT 0xF4 EMIT 0xF8 \ EMIT 0x0F EMIT 0xD4 EMIT 0xCA \ EMIT 0x0F EMIT 0x6E EMIT 0x5F EMIT 0x04 \ EMIT 0x0F EMIT 0xD4 EMIT 0xDC \ EMIT 0x0F EMIT 0x6E EMIT 0x6F EMIT 0x08 \ EMIT 0x0F EMIT 0xD4 EMIT 0xEE \ EMIT 0x0F EMIT 0x6E EMIT 0x67 EMIT 0x0C \ EMIT 0x0F EMIT 0xD4 EMIT 0xFC \ EMIT 0x0F EMIT 0x7E EMIT 0x0F \ EMIT 0x0F EMIT 0x6E EMIT 0x56 EMIT 0x10 \ EMIT 0x0F EMIT 0xF4 EMIT 0xD0 \ EMIT 0x0F EMIT 0x73 EMIT 0xD1 EMIT 0x20 \ EMIT 0x0F EMIT 0x6E EMIT 0x66 EMIT 0x14 \ EMIT 0x0F EMIT 0xF4 EMIT 0xE0 \ EMIT 0x0F EMIT 0xD4 EMIT 0xCB \ EMIT 0x0F EMIT 0x6E EMIT 0x76 EMIT 0x18 \ EMIT 0x0F EMIT 0xF4 EMIT 0xF0 \ EMIT 0x0F EMIT 0x7E EMIT 0x4F EMIT 0x04 \ EMIT 0x0F EMIT 0x73 EMIT 0xD1 EMIT 0x20 \ EMIT 0x0F EMIT 0x6E EMIT 0x5E EMIT 0x1C \ EMIT 0x0F EMIT 0xF4 EMIT 0xD8 \ EMIT 0x0F EMIT 0xD4 EMIT 0xCD \ EMIT 0x0F EMIT 0x6E EMIT 0x6F EMIT 0x10 \ EMIT 0x0F EMIT 0xD4 EMIT 0xD5 \ EMIT 0x0F EMIT 0x7E EMIT 0x4F EMIT 0x08 \ EMIT 0x0F EMIT 0x73 EMIT 0xD1 EMIT 0x20 \ EMIT 0x0F EMIT 0xD4 EMIT 0xCF \ EMIT 0x0F EMIT 0x6E EMIT 0x6F EMIT 0x14 \ EMIT 0x0F EMIT 0xD4 EMIT 0xE5 \ EMIT 0x0F EMIT 0x7E EMIT 0x4F EMIT 0x0C \ EMIT 0x0F EMIT 0x73 EMIT 0xD1 EMIT 0x20 \ EMIT 0x0F EMIT 0xD4 EMIT 0xCA \ EMIT 0x0F EMIT 0x6E EMIT 0x6F EMIT 0x18 \ EMIT 0x0F EMIT 0xD4 EMIT 0xF5 \ EMIT 0x0F EMIT 0x7E EMIT 0x4F EMIT 0x10 \ EMIT 0x0F EMIT 0x73 EMIT 0xD1 EMIT 0x20 \ EMIT 0x0F EMIT 0xD4 EMIT 0xCC \ EMIT 0x0F EMIT 0x6E EMIT 0x6F EMIT 0x1C \ EMIT 0x0F EMIT 0xD4 EMIT 0xDD \ EMIT 0x0F EMIT 0x7E EMIT 0x4F EMIT 0x14 \ EMIT 0x0F EMIT 0x73 EMIT 0xD1 EMIT 0x20 \ EMIT 0x0F EMIT 0xD4 EMIT 0xCE \ EMIT 0x0F EMIT 0x7E EMIT 0x4F EMIT 0x18 \ EMIT 0x0F EMIT 0x73 EMIT 0xD1 EMIT 0x20 \ EMIT 0x0F EMIT 0xD4 EMIT 0xCB \ EMIT 0x0F EMIT 0x7E EMIT 0x4F EMIT 0x1C \ EMIT 0x83 EMIT 0xC7 EMIT 0x20 \ EMIT 0x83 EMIT 0xC6 EMIT 0x20 \ EMIT 0x0F EMIT 0x73 EMIT 0xD1 EMIT 0x20 \ EMIT 0x0F EMIT 0x7E EMIT 0xC9 #define MULADDC_STOP \ EMIT 0x0F EMIT 0x77 \ __asm mov c, ecx \ __asm mov d, edi \ __asm mov s, esi \ #else #define MULADDC_STOP \ __asm mov c, ecx \ __asm mov d, edi \ __asm mov s, esi \ #endif /* SSE2 */ #endif /* MSVC */ #endif /* BSCOMPTLS_HAVE_ASM */ #if !defined(MULADDC_CORE) #if defined(BSCOMPTLS_HAVE_UDBL) #define MULADDC_INIT \ { \ bscomptls_t_udbl r; \ bscomptls_mpi_uint r0, r1; #define MULADDC_CORE \ r = *(s++) * (bscomptls_t_udbl) b; \ r0 = (bscomptls_mpi_uint) r; \ r1 = (bscomptls_mpi_uint)( r >> biL ); \ r0 += c; r1 += (r0 < c); \ r0 += *d; r1 += (r0 < *d); \ c = r1; *(d++) = r0; #define MULADDC_STOP \ } #else #define MULADDC_INIT \ { \ bscomptls_mpi_uint s0, s1, b0, b1; \ bscomptls_mpi_uint r0, r1, rx, ry; \ b0 = ( b << biH ) >> biH; \ b1 = ( b >> biH ); #define MULADDC_CORE \ s0 = ( *s << biH ) >> biH; \ s1 = ( *s >> biH ); s++; \ rx = s0 * b1; r0 = s0 * b0; \ ry = s1 * b0; r1 = s1 * b1; \ r1 += ( rx >> biH ); \ r1 += ( ry >> biH ); \ rx <<= biH; ry <<= biH; \ r0 += rx; r1 += (r0 < rx); \ r0 += ry; r1 += (r0 < ry); \ r0 += c; r1 += (r0 < c); \ r0 += *d; r1 += (r0 < *d); \ c = r1; *(d++) = r0; #define MULADDC_STOP \ } #endif /* C (generic) */ #endif /* C (longlong) */ #endif /* bn_mul.h */

zhangdi29@ezvizlife.com

cabba92ee5f892439dace63414b4d8fc09133bc1

c40a385d7ede8cb17667ae3e3d4b8b48bab49601

/Core/Src/gpio.c

3710d570953287c85dd33c482aa0678282fd8be0

no_license

kubot080301/stm32_test

17c537b6404fcd3f747308ddf550b831c945d0ee

1241187af2e24cf3716f4df4aed3be01c551f6a5

refs/heads/HAL_LED

Makefile

UTF-8

C

c

/** ****************************************************************************** * @file gpio.c * @brief This file provides code for the configuration * of all used GPIO pins. ****************************************************************************** * @attention * * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics. * All rights reserved.</center></h2> * * This software component is licensed by ST under BSD 3-Clause license, * the "License"; You may not use this file except in compliance with the * License. You may obtain a copy of the License at: * opensource.org/licenses/BSD-3-Clause * ****************************************************************************** */ /* Includes ------------------------------------------------------------------*/ #include "gpio.h" /* USER CODE BEGIN 0 */ /* USER CODE END 0 */ /*----------------------------------------------------------------------------*/ /* Configure GPIO */ /*----------------------------------------------------------------------------*/ /* USER CODE BEGIN 1 */ /* USER CODE END 1 */ /** Configure pins as * Analog * Input * Output * EVENT_OUT * EXTI */ void MX_GPIO_Init(void) { GPIO_InitTypeDef GPIO_InitStruct = {0}; /* GPIO Ports Clock Enable */ __HAL_RCC_GPIOH_CLK_ENABLE(); __HAL_RCC_GPIOA_CLK_ENABLE(); __HAL_RCC_GPIOG_CLK_ENABLE(); /*Configure GPIO pin Output Level */ HAL_GPIO_WritePin(GPIOG, LED1_Pin|LED2_Pin, GPIO_PIN_SET); /*Configure GPIO pins : PGPin PGPin */ GPIO_InitStruct.Pin = LED1_Pin|LED2_Pin; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; HAL_GPIO_Init(GPIOG, &GPIO_InitStruct); } /* USER CODE BEGIN 2 */ /* USER CODE END 2 */ /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

70013856+kubot080301@users.noreply.github.com

326c8aca73d729ed1466243b8b049e01d6d375c6

5bc04daeef5284871264a7446aadf7552ec0d195

/lib/percy/cryptominisat/src/sql_tablestructure.h

43bee8b2e5e0a707451d4e35dae57ac2c593563b

permissive

Ace-Ma/LSOracle

a8fd7efe8927f8154ea37407bac727e409098ed5

6e940906303ef6c2c6b96352f44206567fdd50d3

refs/heads/master

MIT

UTF-8

C

h

/************************************************************* MiniSat --- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson CryptoMiniSat --- Copyright (c) 2014, Mate Soos 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. ***************************************************************/ #ifndef __SQL_TABLESTRUCTURE_H__ #define __SQL_TABLESTRUCTURE_H__ extern char cmsat_tablestructure_sql[]; extern unsigned int cmsat_tablestructure_sql_len; #endif

u1219556@lnissrv4.eng.utah.edu

61a880f4c33d12d813d8f2407ff0039d09d25584

a65ebc49769ef9cb0f670a0e233349dd37b8f75d

/ADC.h

4af4c109d8b62d5ebb12339c2923cdb70303d92c

no_license

willisoa/Sound_Visualizer

a984ada2d74608f22dcafd3bf21ef2dd591d1bbc

e4a4403ae7a8222823ee9548b535327b431faba7

refs/heads/master

UTF-8

C

h

/* * ADC.h * * Created on: Jun 21, 2018 * Author: willi */ #ifndef ADC_H_ #define ADC_H_ void ADC_Init(void); int ADC_ResultReady(); void ADC_ResultRead(); int ADC_GetResult(); #endif /* ADC_H_ */

willisoa@mail.gvsu.edu

db78316e94c58b7370f94241359ef1b2feb55a55

63b4a698bc22fd54857c8fa097b1331f79c39e5a

/src/uclibc/uClibc-0.9.33.2/test/stat/stat.c

4980cdd78b33640d2c2c7de15afd9cea13884d15

permissive

MinimSecure/unum-sdk

67e04e2b230f9afb3ae328501a16afa4b94cdac6

30c63f0eccddba39a760671a831be3602842f3f4

refs/heads/master

Apache-2.0

C

UTF-8

C

c

#include <stdio.h> #include <string.h> #include <fcntl.h> #include <sys/stat.h> #include <unistd.h> #include <stdlib.h> static void print_struct_stat(char *msg, struct stat *s) { printf("%s\n", msg); /* The casts are because glibc thinks it's cool */ printf("device : 0x%llx\n",(long long)s->st_dev); printf("inode : %lld\n", (long long)s->st_ino); printf("mode : 0x%llx\n",(long long)s->st_mode); printf("nlink : %lld\n", (long long)s->st_nlink); printf("uid : %lld\n", (long long)s->st_uid); printf("gid : %lld\n", (long long)s->st_gid); printf("rdev : 0x%llx\n",(long long)s->st_rdev); printf("size : %lld\n", (long long)s->st_size); printf("blksize : %lld\n", (long long)s->st_blksize); printf("blocks : %lld\n", (long long)s->st_blocks); printf("atime : %lld\n", (long long)s->st_atime); printf("mtime : %lld\n", (long long)s->st_mtime); printf("ctime : %lld\n", (long long)s->st_ctime); } int main(int argc,char **argv) { int fd, ret; char *file; struct stat s; if (argc < 2) { fprintf(stderr, "Usage: stat FILE\n"); exit(1); } file = argv[1]; memset(&s, 0, sizeof(struct stat)); ret = stat(file, &s); if(ret<0){ perror("stat"); exit(1); } print_struct_stat("\nTesting stat:", &s); memset(&s, 0, sizeof(struct stat)); ret = lstat(file, &s); if(ret<0){ perror("lstat"); exit(1); } print_struct_stat("\nTesting lstat:", &s); fd = open(file, O_RDONLY); if(fd<0){ perror("open"); exit(1); } memset(&s, 0, sizeof(struct stat)); ret = fstat(fd,&s); if(ret<0){ perror("fstat"); exit(1); } print_struct_stat("\nTesting fstat:", &s); exit(0); }

denis.bakin@minim.co

65f77212d5e067076dfaccd169a3fafdd1fc7751

b2a07c363daa20974a7822cf04ed8aa2499cf5f7

/I2S—录音与回放/User/i2c/i2c.c

36e64b6a5b861c26efb27782fae85890bb45e754

no_license

capsper1/ebf_stm32h743_tiaozhanzhe_code

5e77be0bb726936a3b71a740177cd91735d5bfa8

a1d644ff1be4601571fb60f4fb33480c59013ff4

refs/heads/master

GB18030

C

c

/** ****************************************************************************** * @file i2c.c * @author fire * @version V1.0 * @date 2015-xx-xx * @brief i2c 总线驱动，方便与各种I2C传感器通讯。 ****************************************************************************** * @attention * * 实验平台:秉火 STM32 F767 开发板 * 论坛 :http://www.firebbs.cn * 淘宝 :http://firestm32.taobao.com * ****************************************************************************** */ #include "./i2c/i2c.h" #include "./delay/core_delay.h" I2C_HandleTypeDef I2C_Handle; /******************************* Function ************************************/ /** * @brief 初始化I2C总线，使用I2C前需要调用 * @param 无 * @retval 无 */ void I2cMaster_Init(void) { GPIO_InitTypeDef GPIO_InitStructure; /* 使能I2Cx时钟 */ SENSORS_I2C_RCC_CLK_ENABLE(); /* 使能I2C GPIO 时钟 */ SENSORS_I2C_SCL_GPIO_CLK_ENABLE(); SENSORS_I2C_SDA_GPIO_CLK_ENABLE(); /* 配置I2Cx引脚: SCL ----------------------------------------*/ GPIO_InitStructure.Pin = SENSORS_I2C_SCL_GPIO_PIN; GPIO_InitStructure.Mode = GPIO_MODE_AF_OD; GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStructure.Pull= GPIO_NOPULL; GPIO_InitStructure.Alternate=SENSORS_I2C_AF; HAL_GPIO_Init(SENSORS_I2C_SCL_GPIO_PORT, &GPIO_InitStructure); /* 配置I2Cx引脚: SDA ----------------------------------------*/ GPIO_InitStructure.Pin = SENSORS_I2C_SDA_GPIO_PIN; HAL_GPIO_Init(SENSORS_I2C_SDA_GPIO_PORT, &GPIO_InitStructure); if(HAL_I2C_GetState(&I2C_Handle) == HAL_I2C_STATE_RESET) { /* 强制复位I2C外设时钟 */ SENSORS_I2C_FORCE_RESET(); /* 释放I2C外设时钟复位 */ SENSORS_I2C_RELEASE_RESET(); /* I2C 配置 */ I2C_Handle.Instance = SENSORS_I2C; I2C_Handle.Init.Timing = 0x40604E73;//100KHz I2C_Handle.Init.OwnAddress1 = 0; I2C_Handle.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT; I2C_Handle.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE; I2C_Handle.Init.OwnAddress2 = 0; I2C_Handle.Init.OwnAddress2Masks = I2C_OA2_NOMASK; I2C_Handle.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE; I2C_Handle.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE; /* 初始化I2C */ HAL_I2C_Init(&I2C_Handle); /* 使能模拟滤波器 */ HAL_I2CEx_AnalogFilter_Config(&I2C_Handle, I2C_ANALOGFILTER_ENABLE); } } /** * @brief Manages error callback by re-initializing I2C. * @param Addr: I2C Address * @retval None */ static void I2Cx_Error(uint8_t Addr) { /* 恢复I2C寄存器为默认值 */ HAL_I2C_DeInit(&I2C_Handle); /* 重新初始化I2C外设 */ I2cMaster_Init(); } /** * @brief 写寄存器，这是提供给上层的接口 * @param slave_addr: 从机地址 * @param reg_addr:寄存器地址 * @param len：写入的长度 * @param data_ptr:指向要写入的数据 * @retval 正常为0，不正常为非0 */ int Sensors_I2C_WriteRegister(unsigned char slave_addr, unsigned char reg_addr, unsigned short len, unsigned char *data_ptr) { HAL_StatusTypeDef status = HAL_OK; status = HAL_I2C_Mem_Write(&I2C_Handle, slave_addr, reg_addr, I2C_MEMADD_SIZE_8BIT,data_ptr, len,I2Cx_FLAG_TIMEOUT); /* 检查通讯状态 */ if(status != HAL_OK) { /* 总线出错处理 */ I2Cx_Error(slave_addr); } while (HAL_I2C_GetState(&I2C_Handle) != HAL_I2C_STATE_READY) { } /* 检查SENSOR是否就绪进行下一次读写操作 */ while (HAL_I2C_IsDeviceReady(&I2C_Handle, slave_addr, I2Cx_FLAG_TIMEOUT, I2Cx_FLAG_TIMEOUT) == HAL_TIMEOUT); /* 等待传输结束 */ while (HAL_I2C_GetState(&I2C_Handle) != HAL_I2C_STATE_READY) { } return status; } /** * @brief 读寄存器，这是提供给上层的接口 * @param slave_addr: 从机地址 * @param reg_addr:寄存器地址 * @param len：要读取的长度 * @param data_ptr:指向要存储数据的指针 * @retval 正常为0，不正常为非0 */ int Sensors_I2C_ReadRegister(unsigned char slave_addr, unsigned char reg_addr, unsigned short len, unsigned char *data_ptr) { HAL_StatusTypeDef status = HAL_OK; status =HAL_I2C_Mem_Read(&I2C_Handle,slave_addr,reg_addr,I2C_MEMADD_SIZE_8BIT,data_ptr,len,I2Cx_FLAG_TIMEOUT); /* 检查通讯状态 */ if(status != HAL_OK) { /* 总线出错处理 */ I2Cx_Error(slave_addr); } while (HAL_I2C_GetState(&I2C_Handle) != HAL_I2C_STATE_READY) { } /* 检查SENSOR是否就绪进行下一次读写操作 */ while (HAL_I2C_IsDeviceReady(&I2C_Handle, slave_addr, I2Cx_FLAG_TIMEOUT, I2Cx_FLAG_TIMEOUT) == HAL_TIMEOUT); /* 等待传输结束 */ while (HAL_I2C_GetState(&I2C_Handle) != HAL_I2C_STATE_READY) { } return status; }

18575131670@163.com

1415cd4451df6fa9dadff59056ffdf148cfc4b74

8b0b44281662be6f0b4b8d2c952f2bf56382bc27

/05-structures/02-arrays-of-structures/main.c

d912107c8a18cd784b5e6161abb2d946aa0d4f6b

no_license

Misael1998/learning-c

42f4530fb9482600427448947fd040b817cec809

134b407d2b633013d26f4653f79e93b600ebb860

refs/heads/main

UTF-8

C

c

#include <stdio.h> #include <ctype.h> #include <string.h> #define MAXWORD 100 struct key { char *word; int count; } keytab[] = { "auto", 0, "break", 0, "case", 0, "char", 0, "const", 0, "continue", 0, "default", 0, /* ... */ "unsigned", 0, "void", 0, "volatile", 0, "while", 0 }; /* NKEYS: elements in keytab counted by the computer at compile time */ #define NKEYS (sizeof(keytab)/sizeof(struct key)) int getword(char *, int); int binsearch(char *, struct key *, int); /* count C keywords */ int main() { int n; char word[MAXWORD]; while (getword(word, MAXWORD) != EOF) if (isalpha(word[0])) if ((n = binsearch(word, keytab, NKEYS)) >= 0) keytab[n].count++; for (n = 0; n < NKEYS; n++) if (keytab[n].count > 0) printf("%4d %s\n", keytab[n].count, keytab[n].word); return 0; } /* binsearch: find word in tab[0]...tab[n-1] */ int binsearch(char *word, struct key tab[], int n) { int cond; int low, high, mid; low = 0; high = n - 1; while (low <= high) { mid = (low+high)/2; if ((cond = strcmp(word, tab[mid].word)) < 0) high = mid - 1; else if (cond > 0) low = mid + 1; else return mid; } return -1; }

misalande@gmail.com

5a9a6abf3f12aac6293cecd1950d52e4a9480edd

d8cec3d9496ed5b108e2b354abbf9601ed5f0b2a

/binary_search.c

4c7956d70b8410403e00c3db928bd0bb0b474ed8

no_license

yehyun3459/algorithm

214282f4d42d9199917598ab46569437e93d0a3a

838135877f8df0ab04d9db4621a7734fbea8da7a

refs/heads/master

UHC

C

c

#include <stdio.h> #define ARR_LEN 10 int binarySearch(int *arr,int key) { int r_index = -99; int start = 0, end = ARR_LEN - 1; while(1) { int mid = (start + end) / 2; if (arr[mid] == key) return mid; else if (arr[mid] > key)end = mid; else start = mid + 1; if (start == end&&arr[start] != key)break; } return r_index; } void main() { int _arr[] = { 14,17,20,22,26,48,50,90,95,100 }; int key; while (EOF) { printf("찾고자 하는 수를 입력하세요\n[14,17,20,22,26,48,50,90,95,100]중에서*^^*\n"); scanf("%d", &key); int index = binarySearch(_arr, key); if(index!=-99) printf("%d is stored in %dth index in arr\n", key, index + 1); else printf("없는 값을 입력하셨네요 ^////^"); } }

yehyun3459@naver.com

de4c9d43cf9459e3ef357bb267e96e8ab8c74b44

b945b2fac11f237a49de33af1b8fa02ba3ed1814

/bspmath/include/prototypes/bsfilendpar.h

af9ba4c157d97d4973faadd972018bf62ae46187

no_license

ahundiak/isdp

b94f56f7a7b02b806209ff06da8e22497f6e1386

07572eb18f07cbf762505ef34e471fa47c102df4

refs/heads/master

UTF-8

C

h

/* /usr3/bs/src.em/bsfilendpar.c */ extern void BSfilendpar(IGRint, IGRdouble, IGRdouble, IGRdouble, IGRint, IGRint, BSpair *, IGRint [2], BSrc *);

ahundiak@e9faf64c-7e38-11de-a453-d5a50d962d30

756494c91046b7f91a149beca515f3a98db926e5

3ed978164e91956cb360f9916070ada31bf80e27

/srcs/glob/glob_tablejoin.c

0875e35e4219eebadd0a35d58a9da7420b49d654

no_license

jguyet/42sh

54613a115d2b2afb96a1bb8355bdb069635ccd7b

4339fb44fa4cbad9789ddc7e6361ea70302c9cd6

refs/heads/master

UTF-8

C

c

/* ************************************************************************** */ /* */ /* ::: :::::::: */ /* glob_tablejoin.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: mblet <mblet@student.42.fr> +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/04/29 18:22:01 by mblet #+# #+# */ /* Updated: 2016/05/19 01:51:37 by mblet ### ########.fr */ /* */ /* ************************************************************************** */ #include "glob.h" char **sh_glob_tablejoind(char **table1, char **table2) { char **ret; size_t i; size_t j; ret = (char **)malloc((ft_strtable_size(table1) \ + ft_strtable_size(table2) + 1) * sizeof(char *)); if (ret == NULL) return (NULL); i = 0; j = 0; while (table1 && table1[j]) ret[i++] = ft_strdup(table1[j++]); j = 0; while (table2 && table2[j]) ret[i++] = ft_strdup(table2[j++]); ret[i] = NULL; ft_strtable_clear(&table1); ft_strtable_clear(&table2); return (ret); }

jguyet@e3r1p12.42.fr

1edfe833fd0bfe1b868357e8047416fde0d34d03

02e2f32edb8df4013061776c12c50292e85e8a6e

/src/nucleus/ft_cut_copy.c

386fcdde3a453c2771f7d552f6553dba1468a029

no_license

pankratdodo/21sh

1de930ab2257999b214784ec3832c1c87d7df8bd

a61d1910b36f8589d06f73390b1abf844a6e4a79

refs/heads/master

UTF-8

C

c

/* ************************************************************************** */ /* */ /* ::: :::::::: */ /* ft_cut_copy.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: qmartina <marvin@42.fr> +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2020/01/27 17:49:33 by qmartina #+# #+# */ /* Updated: 2020/01/27 17:49:34 by qmartina ### ########.fr */ /* */ /* ************************************************************************** */ #include "../../inc/fshell.h" void ft_cut_copy(t_readline *p) { char *tmp; if (p->sum_read == 25) ft_putcut(p); else if (p->sum_read == 23) { free(g_cp); g_cp = ft_strndup(p->buff, p->index); tmp = p->buff; p->buff = ft_strndup(&tmp[p->index], (p->len - p->index)); free(tmp); ft_cleanstr(p->index + p->len_hint, p); p->index = 0; p->len = ft_strlen(p->buff); p->buff_size = p->len; p->len_hint = ft_printf_helper(p->mod); write(2, p->buff, p->len); ft_setcursor(0, p->len); } else if (p->sum_read == 21) ft_cut(p); else if (p->sum_read == 127 && p->index > 0) ft_do_delch(p); }

plettie@mi-q5.21-school.ru

9f6d231ad84008b479ecfd7312376ec07fe56433

be3167504c0e32d7708e7d13725c2dbc9232f2cb

/mame/src/mame/video/hyprduel.c

b76ea0787ef0284ca2f66abcf3b42fcc7c27a322

no_license

sysfce2/MAME-Plus-Plus-Kaillera

83b52085dda65045d9f5e8a0b6f3977d75179e78

9692743849af5a808e217470abc46e813c9068a5

refs/heads/master

UTF-8

C

c

/* based on driver from video/metro.c by Luca Elia */ /* modified by Hau */ /*************************************************************************** -= Metro Games =- driver by Luca Elia (l.elia@tin.it) Note: if MAME_DEBUG is defined, pressing Z with: Q Shows Layer 0 W Shows Layer 1 E Shows Layer 2 A Shows Sprites Keys can be used together! [ 3 Scrolling Layers ] There is memory for a huge layer, but the actual tilemap is a smaller window (of fixed size) carved from anywhere inside that layer. Tile Size: 8 x 8 x 4 (later games can switch to 8 x 8 x 8, 16 x 16 x 4/8 at run time) Big Layer Size: 2048 x 2048 (8x8 tiles) or 4096 x 4096 (16x16 tiles) Tilemap Window Size: 512 x 256 (8x8 tiles) or 1024 x 512 (16x16 tiles) The tile codes in memory do not map directly to tiles. They are indexes into a table (with 0x200 entries) that defines a virtual set of tiles for the 3 layers. Each entry in that table adds 16 tiles to the set of available tiles, and decides their color code. Tile code with their msbit set are different as they mean: draw a tile filled with a single color (0-1ff) [ 512 Zooming Sprites ] The sprites are NOT tile based: the "tile" size can vary from 8 to 64 (independently for width and height) with an 8 pixel granularity. The "tile" address is a multiple of 8x8 pixels. Each sprite can be shrinked to ~1/4 or enlarged to ~32x following an exponential curve of sizes (with one zoom value for both width and height) ***************************************************************************/ #include "emu.h" #include "includes/hyprduel.h" /*************************************************************************** Palette GGGGGRRRRRBBBBBx ***************************************************************************/ WRITE16_MEMBER(hyprduel_state::hyprduel_paletteram_w) { data = COMBINE_DATA(&m_paletteram[offset]); palette_set_color_rgb(machine(), offset, pal5bit(data >> 6), pal5bit(data >> 11), pal5bit(data >> 1)); } /*************************************************************************** Tilemaps: Tiles Set & Window Each entry in the Tiles Set RAM uses 2 words to specify a starting tile code and a color code. This adds 16 consecutive tiles with that color code to the set of available tiles. Offset: Bits: Value: 0.w fedc ---- ---- ---- ---- ba98 7654 ---- Color Code ---- ---- ---- 3210 Code High Bits 2.w Code Low Bits ***************************************************************************/ /*************************************************************************** Tilemaps: Rendering ***************************************************************************/ /* A 2048 x 2048 virtual tilemap */ #define BIG_NX (0x100) #define BIG_NY (0x100) /* A smaller 512 x 256 window defines the actual tilemap */ #define WIN_NX (0x40) #define WIN_NY (0x20) //#define WIN_NX (0x40+1) //#define WIN_NY (0x20+1) /* 8x8x4 tiles only */ INLINE void get_tile_info( running_machine &machine, tile_data &tileinfo, int tile_index, int layer, UINT16 *vram) { hyprduel_state *state = machine.driver_data<hyprduel_state>(); UINT16 code; int table_index; UINT32 tile; /* The actual tile index depends on the window */ tile_index = ((tile_index / WIN_NX + state->m_window[layer * 2 + 0] / 8) % BIG_NY) * BIG_NX + ((tile_index % WIN_NX + state->m_window[layer * 2 + 1] / 8) % BIG_NX); /* Fetch the code */ code = vram[tile_index]; /* Use it as an index into the tiles set table */ table_index = ((code & 0x1ff0) >> 4 ) * 2; tile = (state->m_tiletable[table_index + 0] << 16) + state->m_tiletable[table_index + 1]; if (code & 0x8000) /* Special: draw a tile of a single color (i.e. not from the gfx ROMs) */ { int _code = code & 0x000f; tileinfo.pen_data = state->m_empty_tiles + _code * 16 * 16; tileinfo.palette_base = ((code & 0x0ff0)) + 0x1000; tileinfo.flags = 0; tileinfo.group = 0; } else { tileinfo.group = 0; SET_TILE_INFO( 0, (tile & 0xfffff) + (code & 0xf), (((tile & 0x0ff00000) >> 20)) + 0x100, TILE_FLIPXY((code & 0x6000) >> 13)); } } /* 8x8x4 or 8x8x8 tiles. It's the tile's color that decides: if its low 4 bits are high ($f,$1f,$2f etc) the tile is 8bpp, otherwise it's 4bpp */ INLINE void get_tile_info_8bit( running_machine &machine, tile_data &tileinfo, int tile_index, int layer, UINT16 *vram ) { hyprduel_state *state = machine.driver_data<hyprduel_state>(); UINT16 code; int table_index; UINT32 tile; /* The actual tile index depends on the window */ tile_index = ((tile_index / WIN_NX + state->m_window[layer * 2 + 0] / 8) % BIG_NY) * BIG_NX + ((tile_index % WIN_NX + state->m_window[layer * 2 + 1] / 8) % BIG_NX); /* Fetch the code */ code = vram[tile_index]; /* Use it as an index into the tiles set table */ table_index = ((code & 0x1ff0) >> 4) * 2; tile = (state->m_tiletable[table_index + 0] << 16) + state->m_tiletable[table_index + 1]; if (code & 0x8000) /* Special: draw a tile of a single color (i.e. not from the gfx ROMs) */ { int _code = code & 0x000f; tileinfo.pen_data = state->m_empty_tiles + _code * 16 * 16; tileinfo.palette_base = ((code & 0x0ff0)) + 0x1000; tileinfo.flags = 0; tileinfo.group = 0; } else if ((tile & 0x00f00000) == 0x00f00000) /* draw tile as 8bpp */ { tileinfo.group = 1; SET_TILE_INFO( 1, (tile & 0xfffff) + 2*(code & 0xf), ((tile & 0x0f000000) >> 24) + 0x10, TILE_FLIPXY((code & 0x6000) >> 13)); } else { tileinfo.group = 0; SET_TILE_INFO( 0, (tile & 0xfffff) + (code & 0xf), (((tile & 0x0ff00000) >> 20)) + 0x100, TILE_FLIPXY((code & 0x6000) >> 13)); } } /* 16x16x4 or 16x16x8 tiles. It's the tile's color that decides: if its low 4 bits are high ($f,$1f,$2f etc) the tile is 8bpp, otherwise it's 4bpp */ INLINE void get_tile_info_16x16_8bit( running_machine &machine, tile_data &tileinfo, int tile_index, int layer, UINT16 *vram ) { hyprduel_state *state = machine.driver_data<hyprduel_state>(); UINT16 code; int table_index; UINT32 tile; /* The actual tile index depends on the window */ tile_index = ((tile_index / WIN_NX + state->m_window[layer * 2 + 0] / 8) % BIG_NY) * BIG_NX + ((tile_index % WIN_NX + state->m_window[layer * 2 + 1] / 8) % BIG_NX); /* Fetch the code */ code = vram[tile_index]; /* Use it as an index into the tiles set table */ table_index = ((code & 0x1ff0) >> 4) * 2; tile = (state->m_tiletable[table_index + 0] << 16) + state->m_tiletable[table_index + 1]; if (code & 0x8000) /* Special: draw a tile of a single color (i.e. not from the gfx ROMs) */ { int _code = code & 0x000f; tileinfo.pen_data = state->m_empty_tiles + _code * 16 * 16; tileinfo.palette_base = ((code & 0x0ff0)) + 0x1000; tileinfo.flags = 0; tileinfo.group = 0; } else if ((tile & 0x00f00000) == 0x00f00000) /* draw tile as 8bpp */ { tileinfo.group = 1; SET_TILE_INFO( 3, (tile & 0xfffff) + 8*(code & 0xf), ((tile & 0x0f000000) >> 24) + 0x10, TILE_FLIPXY((code & 0x6000) >> 13)); } else { tileinfo.group = 0; SET_TILE_INFO( 2, (tile & 0xfffff) + 4*(code & 0xf), (((tile & 0x0ff00000) >> 20)) + 0x100, TILE_FLIPXY((code & 0x6000) >> 13)); } } INLINE void hyprduel_vram_w( running_machine &machine, offs_t offset, UINT16 data, UINT16 mem_mask, int layer, UINT16 *vram ) { hyprduel_state *state = machine.driver_data<hyprduel_state>(); COMBINE_DATA(&vram[offset]); { /* Account for the window */ int col = (offset % BIG_NX) - ((state->m_window[layer * 2 + 1] / 8) % BIG_NX); int row = (offset / BIG_NX) - ((state->m_window[layer * 2 + 0] / 8) % BIG_NY); if (col < -(BIG_NX-WIN_NX)) col += (BIG_NX-WIN_NX) + WIN_NX; if (row < -(BIG_NY-WIN_NY)) row += (BIG_NY-WIN_NY) + WIN_NY; if ((col >= 0) && (col < WIN_NX) && (row >= 0) && (row < WIN_NY)) state->m_bg_tilemap[layer]->mark_tile_dirty(row * WIN_NX + col); } } TILE_GET_INFO_MEMBER(hyprduel_state::get_tile_info_0_8bit) { get_tile_info_8bit(machine(), tileinfo, tile_index, 0, m_vram_0); } TILE_GET_INFO_MEMBER(hyprduel_state::get_tile_info_1_8bit) { get_tile_info_8bit(machine(), tileinfo, tile_index, 1, m_vram_1); } TILE_GET_INFO_MEMBER(hyprduel_state::get_tile_info_2_8bit) { get_tile_info_8bit(machine(), tileinfo, tile_index, 2, m_vram_2); } WRITE16_MEMBER(hyprduel_state::hyprduel_vram_0_w) { hyprduel_vram_w(machine(), offset, data, mem_mask, 0, m_vram_0); } WRITE16_MEMBER(hyprduel_state::hyprduel_vram_1_w) { hyprduel_vram_w(machine(), offset, data, mem_mask, 1, m_vram_1); } WRITE16_MEMBER(hyprduel_state::hyprduel_vram_2_w) { hyprduel_vram_w(machine(), offset, data, mem_mask, 2, m_vram_2); } /* Dirty the relevant tilemap when its window changes */ WRITE16_MEMBER(hyprduel_state::hyprduel_window_w) { UINT16 olddata = m_window[offset]; UINT16 newdata = COMBINE_DATA(&m_window[offset]); if (newdata != olddata) { offset /= 2; m_bg_tilemap[offset]->mark_all_dirty(); } } /*************************************************************************** Video Init Routines ***************************************************************************/ /* Sprites are not tile based, so we decode their graphics at runtime. We can't do it at startup because drawgfx requires the tiles to be pre-rotated to support vertical games, and that, in turn, requires the tile's sizes to be known at startup - which we don't! */ static void alloc_empty_tiles( running_machine &machine ) { hyprduel_state *state = machine.driver_data<hyprduel_state>(); int code,i; state->m_empty_tiles = auto_alloc_array(machine, UINT8, 16*16*16); state->save_pointer(NAME(state->m_empty_tiles), 16*16*16); for (code = 0; code < 0x10; code++) for (i = 0; i < 16 * 16; i++) state->m_empty_tiles[16 * 16 * code + i] = code; } static void hyprduel_postload(running_machine &machine) { hyprduel_state *state = machine.driver_data<hyprduel_state>(); int i; for (i = 0; i < 3; i++) { UINT16 wx = state->m_window[i * 2 + 1]; UINT16 wy = state->m_window[i * 2 + 0]; state->m_bg_tilemap[i]->set_scrollx(0, state->m_scroll[i * 2 + 1] - wx - (wx & 7)); state->m_bg_tilemap[i]->set_scrolly(0, state->m_scroll[i * 2 + 0] - wy - (wy & 7)); state->m_bg_tilemap[i]->mark_all_dirty(); } } static void expand_gfx1(hyprduel_state &state) { UINT8 *base_gfx = state.machine().root_device().memregion("gfx1")->base(); UINT32 length = 2 * state.machine().root_device().memregion("gfx1")->bytes(); state.m_expanded_gfx1 = auto_alloc_array(state.machine(), UINT8, length); for (int i = 0; i < length; i += 2) { UINT8 src = base_gfx[i / 2]; state.m_expanded_gfx1[i+0] = src & 15; state.m_expanded_gfx1[i+1] = src >> 4; } } VIDEO_START_MEMBER(hyprduel_state,common_14220) { expand_gfx1(*this); alloc_empty_tiles(machine()); m_tiletable_old = auto_alloc_array(machine(), UINT16, m_tiletable.bytes() / 2); m_dirtyindex = auto_alloc_array(machine(), UINT8, m_tiletable.bytes() / 4); save_pointer(NAME(m_tiletable_old), m_tiletable.bytes() / 2); save_pointer(NAME(m_dirtyindex), m_tiletable.bytes() / 4); m_bg_tilemap[0] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(hyprduel_state::get_tile_info_0_8bit),this), TILEMAP_SCAN_ROWS, 8, 8, WIN_NX, WIN_NY); m_bg_tilemap[1] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(hyprduel_state::get_tile_info_1_8bit),this), TILEMAP_SCAN_ROWS, 8, 8, WIN_NX, WIN_NY); m_bg_tilemap[2] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(hyprduel_state::get_tile_info_2_8bit),this), TILEMAP_SCAN_ROWS, 8, 8, WIN_NX, WIN_NY); m_bg_tilemap[0]->map_pen_to_layer(0, 15, TILEMAP_PIXEL_TRANSPARENT); m_bg_tilemap[0]->map_pen_to_layer(1, 255, TILEMAP_PIXEL_TRANSPARENT); m_bg_tilemap[1]->map_pen_to_layer(0, 15, TILEMAP_PIXEL_TRANSPARENT); m_bg_tilemap[1]->map_pen_to_layer(1, 255, TILEMAP_PIXEL_TRANSPARENT); m_bg_tilemap[2]->map_pen_to_layer(0, 15, TILEMAP_PIXEL_TRANSPARENT); m_bg_tilemap[2]->map_pen_to_layer(1, 255, TILEMAP_PIXEL_TRANSPARENT); m_bg_tilemap[0]->set_scrolldx(0, 0); m_bg_tilemap[1]->set_scrolldx(0, 0); m_bg_tilemap[2]->set_scrolldx(0, 0); /* Set up save state */ save_item(NAME(m_sprite_xoffs)); save_item(NAME(m_sprite_yoffs)); machine().save().register_postload(save_prepost_delegate(FUNC(hyprduel_postload), &machine())); } VIDEO_START_MEMBER(hyprduel_state,hyprduel_14220) { m_sprite_yoffs_sub = 2; VIDEO_START_CALL_MEMBER(common_14220); } VIDEO_START_MEMBER(hyprduel_state,magerror_14220) { m_sprite_yoffs_sub = 0; VIDEO_START_CALL_MEMBER(common_14220); } /*************************************************************************** Video Registers Offset: Bits: Value: 0.w Number Of Sprites To Draw 2.w f--- ---- ---- ---- Disabled Sprites Layer Priority -edc ---- ---- ---- ---- ba-- ---- ---- Sprites Masked Layer ---- --98 ---- ---- Sprites Priority ---- ---- 765- ---- ---- ---- ---4 3210 Sprites Masked Number 4.w Sprites Y Offset 6.w Sprites X Offset 8.w Sprites Color Codes Start - 10.w fedc ba98 76-- ---- ---- ---- --54 ---- Layer 2 Priority (3 backmost, 0 frontmost) ---- ---- ---- 32-- Layer 1 Priority ---- ---- ---- --10 Layer 0 Priority 12.w Backround Color ***************************************************************************/ /*************************************************************************** Sprites Drawing Offset: Bits: Value: 0.w fedc b--- ---- ---- Priority (0 = Max) ---- -a98 7654 3210 X 2.w fedc ba-- ---- ---- Zoom (Both X & Y) ---- --98 7654 3210 Y 4.w f--- ---- ---- ---- Flip X -e-- ---- ---- ---- Flip Y --dc b--- ---- ---- Size X * ---- -a98 ---- ---- Size Y * ---- ---- 7654 ---- Color ---- ---- ---- 3210 Code High Bits ** 6.w Code Low Bits ** * 8 pixel increments ** 8x8 pixel increments ***************************************************************************/ /* Draw sprites */ static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect ) { hyprduel_state *state = machine.driver_data<hyprduel_state>(); UINT8 *base_gfx4 = state->m_expanded_gfx1; UINT8 *base_gfx8 = state->memregion("gfx1")->base(); UINT32 gfx_size = state->memregion("gfx1")->bytes(); int max_x = machine.primary_screen->width(); int max_y = machine.primary_screen->height(); int max_sprites = state->m_spriteram.bytes() / 8; int sprites = state->m_videoregs[0x00 / 2] % max_sprites; int color_start = ((state->m_videoregs[0x08 / 2] & 0xf) << 4) + 0x100; int i, j, pri; static const int primask[4] = { 0x0000, 0xff00, 0xff00|0xf0f0, 0xff00|0xf0f0|0xcccc }; UINT16 *src; int inc; if (sprites == 0) return; for (i = 0; i < 0x20; i++) { if (!(state->m_videoregs[0x02 / 2] & 0x8000)) { src = state->m_spriteram + (sprites - 1) * (8 / 2); inc = -(8 / 2); } else { src = state->m_spriteram; inc = (8 / 2); } for (j = 0; j < sprites; j++) { int x, y, attr, code, color, flipx, flipy, zoom, curr_pri, width, height; /* Exponential zoom table extracted from daitoride */ static const int zoomtable[0x40] = { 0xAAC,0x800,0x668,0x554,0x494,0x400,0x390,0x334, 0x2E8,0x2AC,0x278,0x248,0x224,0x200,0x1E0,0x1C8, 0x1B0,0x198,0x188,0x174,0x164,0x154,0x148,0x13C, 0x130,0x124,0x11C,0x110,0x108,0x100,0x0F8,0x0F0, 0x0EC,0x0E4,0x0DC,0x0D8,0x0D4,0x0CC,0x0C8,0x0C4, 0x0C0,0x0BC,0x0B8,0x0B4,0x0B0,0x0AC,0x0A8,0x0A4, 0x0A0,0x09C,0x098,0x094,0x090,0x08C,0x088,0x080, 0x078,0x070,0x068,0x060,0x058,0x050,0x048,0x040 }; x = src[0]; curr_pri = (x & 0xf800) >> 11; if ((curr_pri == 0x1f) || (curr_pri != i)) { src += inc; continue; } pri = (state->m_videoregs[0x02 / 2] & 0x0300) >> 8; if (!(state->m_videoregs[0x02 / 2] & 0x8000)) { if (curr_pri > (state->m_videoregs[0x02 / 2] & 0x1f)) pri = (state->m_videoregs[0x02 / 2] & 0x0c00) >> 10; } y = src[1]; attr = src[2]; code = src[3]; flipx = attr & 0x8000; flipy = attr & 0x4000; color = (attr & 0xf0) >> 4; zoom = zoomtable[(y & 0xfc00) >> 10] << (16 - 8); x = (x & 0x07ff) - state->m_sprite_xoffs; y = (y & 0x03ff) - state->m_sprite_yoffs; width = (((attr >> 11) & 0x7) + 1) * 8; height = (((attr >> 8) & 0x7) + 1) * 8; UINT32 gfxstart = (8 * 8 * 4 / 8) * (((attr & 0x000f) << 16) + code); if (state->flip_screen()) { flipx = !flipx; x = max_x - x - width; flipy = !flipy; y = max_y - y - height; } if (color == 0xf) /* 8bpp */ { /* Bounds checking */ if ((gfxstart + width * height - 1) >= gfx_size) continue; gfx_element gfx(machine, base_gfx8 + gfxstart, width, height, width, 0, 256); pdrawgfxzoom_transpen(bitmap,cliprect, &gfx, 0, color_start >> 4, flipx, flipy, x, y, zoom, zoom, machine.priority_bitmap,primask[pri], 255); } else { /* Bounds checking */ if ((gfxstart + width / 2 * height - 1) >= gfx_size) continue; gfx_element gfx(machine, base_gfx4 + 2 * gfxstart, width, height, width, 0, 16); pdrawgfxzoom_transpen(bitmap,cliprect, &gfx, 0, color + color_start, flipx, flipy, x, y, zoom, zoom, machine.priority_bitmap,primask[pri], 15); } #if 0 { /* Display priority + zoom on each sprite */ char buf[80]; sprintf(buf, "%02X %02X",((src[ 0 ] & 0xf800) >> 11)^0x1f,((src[ 1 ] & 0xfc00) >> 10) ); ui_draw_text(buf, x, y); } #endif src += inc; } } } /*************************************************************************** Screen Drawing ***************************************************************************/ WRITE16_MEMBER(hyprduel_state::hyprduel_scrollreg_w) { UINT16 window = m_window[offset]; COMBINE_DATA(&m_scroll[offset]); if (offset & 0x01) m_bg_tilemap[offset / 2]->set_scrollx(0, m_scroll[offset] - window - (window & 7)); else m_bg_tilemap[offset / 2]->set_scrolly(0, m_scroll[offset] - window - (window & 7)); } WRITE16_MEMBER(hyprduel_state::hyprduel_scrollreg_init_w) { int i; for (i = 0; i < 3; i++) { UINT16 wx = m_window[i * 2 + 1]; UINT16 wy = m_window[i * 2 + 0]; m_scroll[i * 2 + 1] = data; m_scroll[i * 2 + 0] = data; m_bg_tilemap[i]->set_scrollx(0, data - wx - (wx & 7)); m_bg_tilemap[i]->set_scrolly(0, data - wy - (wy & 7)); } } static void draw_layers( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int pri, int layers_ctrl ) { hyprduel_state *state = machine.driver_data<hyprduel_state>(); UINT16 layers_pri = state->m_videoregs[0x10/2]; int layer; /* Draw all the layers with priority == pri */ for (layer = 2; layer >= 0; layer--) // tilemap[2] below? { if ( pri == ((layers_pri >> (layer*2)) & 3) ) { if (layers_ctrl & (1 << layer)) // for debug state->m_bg_tilemap[layer]->draw(bitmap, cliprect, 0, 1 << (3 - pri)); } } } /* Dirty tilemaps when the tiles set changes */ static void dirty_tiles( running_machine &machine, int layer, UINT16 *vram ) { hyprduel_state *state = machine.driver_data<hyprduel_state>(); int col, row; for (row = 0; row < WIN_NY; row++) { for (col = 0; col < WIN_NX; col++) { int offset = (col + state->m_window[layer * 2 + 1] / 8) % BIG_NX + ((row + state->m_window[layer * 2 + 0] / 8) % BIG_NY) * BIG_NX; UINT16 code = vram[offset]; if (!(code & 0x8000) && state->m_dirtyindex[(code & 0x1ff0) >> 4]) state->m_bg_tilemap[layer]->mark_tile_dirty(row * WIN_NX + col); } } } SCREEN_UPDATE_IND16( hyprduel ) { hyprduel_state *state = screen.machine().driver_data<hyprduel_state>(); int i, pri, layers_ctrl = -1; UINT16 screenctrl = *state->m_screenctrl; { int dirty = 0; memset(state->m_dirtyindex, 0, state->m_tiletable.bytes() / 4); for (i = 0; i < state->m_tiletable.bytes() / 4; i++) { UINT32 tile_new = (state->m_tiletable[2 * i + 0] << 16 ) + state->m_tiletable[2 * i + 1]; UINT32 tile_old = (state->m_tiletable_old[2 * i + 0] << 16 ) + state->m_tiletable_old[2 * i + 1]; if ((tile_new ^ tile_old) & 0x0fffffff) { state->m_dirtyindex[i] = 1; dirty = 1; } } memcpy(state->m_tiletable_old, state->m_tiletable, state->m_tiletable.bytes()); if (dirty) { dirty_tiles(screen.machine(), 0, state->m_vram_0); dirty_tiles(screen.machine(), 1, state->m_vram_1); dirty_tiles(screen.machine(), 2, state->m_vram_2); } } state->m_sprite_xoffs = state->m_videoregs[0x06 / 2] - screen.width() / 2; state->m_sprite_yoffs = state->m_videoregs[0x04 / 2] - screen.height() / 2 - state->m_sprite_yoffs_sub; /* The background color is selected by a register */ screen.machine().priority_bitmap.fill(0, cliprect); bitmap.fill((state->m_videoregs[0x12 / 2] & 0x0fff) + 0x1000, cliprect); /* Screen Control Register: f--- ---- ---- ---- ? -edc b--- ---- ---- ---- -a98 ---- ---- ? Leds ---- ---- 7--- ---- 16x16 Tiles (Layer 2) ---- ---- -6-- ---- 16x16 Tiles (Layer 1) ---- ---- --5- ---- 16x16 Tiles (Layer 0) ---- ---- ---4 32-- ---- ---- ---- --1- ? Blank Screen ---- ---- ---- ---0 Flip Screen */ if (screenctrl & 2) return 0; state->flip_screen_set(screenctrl & 1); #if 0 if (screen.machine().input().code_pressed(KEYCODE_Z)) { int msk = 0; if (screen.machine().input().code_pressed(KEYCODE_Q)) msk |= 0x01; if (screen.machine().input().code_pressed(KEYCODE_W)) msk |= 0x02; if (screen.machine().input().code_pressed(KEYCODE_E)) msk |= 0x04; if (screen.machine().input().code_pressed(KEYCODE_A)) msk |= 0x08; if (msk != 0) { bitmap.fill(0, cliprect); layers_ctrl &= msk; } popmessage("%x-%x-%x:%04x %04x %04x", state->m_videoregs[0x10/2]&3,(state->m_videoregs[0x10/2] & 0xc) >> 2, (state->m_videoregs[0x10/2] & 0x30) >> 4, state->m_videoregs[0x02/2], state->m_videoregs[0x08/2], *state->m_screenctrl); } #endif for (pri = 3; pri >= 0; pri--) draw_layers(screen.machine(), bitmap, cliprect, pri, layers_ctrl); if (layers_ctrl & 0x08) draw_sprites(screen.machine(), bitmap, cliprect); return 0; }

mameppk@199a702f-54f1-4ac0-8451-560dfe28270b

422ad3573de9a5cfe1d70016e2b6da72fc0382d3

e37c46a141827d831c6868b9677bba95de1e34bb

/bareMetal/dijk15x15/dijkstra_155.c

75d1d99d3e7a2de37b4f68662e23f490d1957f70

no_license

guimadalozzo/OVP-MPSoC-NoC

0eb24342c18b6513ac920c8c44deb15d6be11443

8842cf92068ef64165efe1061e263a6c2e846f52

refs/heads/master

C

UTF-8

C

c

#include <stdlib.h> #include <stdio.h> #include "MPIe.h" #include "tasks_comm.h" #define NONE 9999 //Maximum #define MAXPROCESSORS 64 //The amount of processor #define NUM_NODES 16 //16 for small input; 160 for large input; 30 for medium input; int rank = 155; struct _NODE{ int iDist; int iPrev; int iCatched; }; typedef struct _NODE NODE; struct _UVERTEX{ int iPID; int iNID; int iDist; }; typedef struct _UVERTEX UVERTEX; UVERTEX uVertex[MAXPROCESSORS]; NODE rgnNodes[MAXPROCESSORS][NUM_NODES]; int g_qCount[MAXPROCESSORS]; int paths; int resultSend[33]; int tasks[MAXPROCESSORS][2]; int nodes_tasks[NUM_NODES*(NUM_NODES-1)/2][2]; int AdjMatrix[NUM_NODES][NUM_NODES]; int globalMiniCost[MAXPROCESSORS]; int qtdEnvios = 0; int qcount (int myID){ return(g_qCount[myID]); } void sendPath(NODE *rgnNodes, int chNode){ if ((rgnNodes+chNode)->iPrev != NONE){ sendPath(rgnNodes, (rgnNodes+chNode)->iPrev); } resultSend[paths] = chNode+1; paths++; } void sendResult(int myID,int chStart, int chEnd){ paths = 3; int k; for(k=0; k<33; k++) resultSend[k] = 0; resultSend[0] = chStart; resultSend[1] = chEnd; resultSend[2] = rgnNodes[myID][chEnd].iDist; sendPath(rgnNodes[myID], chEnd); Message msg; msg.length = 33; msg.msg[0] = -1; for(k=0; k<33; k++) msg.msg[k] = resultSend[k]; Send(msg, divider); } void dijkstra(int myID) { int x,i,v; int chStart, chEnd; int u =-1; for(x=tasks[myID][0]; x<tasks[myID][1]; x++){ chStart = nodes_tasks[x][0]; //Start node chEnd = nodes_tasks[x][1]; //End node u=-1; //Initialize and clear uVertex[myID].iDist=NONE; uVertex[myID].iPID=myID; uVertex[myID].iNID=NONE; g_qCount[myID] = 0; u=-1; for (v=0; v<NUM_NODES; v++) { rgnNodes[myID][v].iDist = AdjMatrix[chStart][v]; rgnNodes[myID][v].iPrev = NONE; rgnNodes[myID][v].iCatched = 0; } //Start working while (qcount(myID) < NUM_NODES-1){ for (i=0; i<NUM_NODES; i++) { if(rgnNodes[myID][i].iCatched==0 && rgnNodes[myID][i].iDist<uVertex[myID].iDist && rgnNodes[myID][i].iDist!=0){ uVertex[myID].iDist=rgnNodes[myID][i].iDist; uVertex[myID].iNID=i; } } globalMiniCost[myID]=NONE; if(globalMiniCost[myID]>uVertex[myID].iDist){ globalMiniCost[myID] = uVertex[myID].iDist; u=uVertex[myID].iNID; g_qCount[myID]++; } for (v=0; v<NUM_NODES; v++) { if(v==u){ rgnNodes[myID][v].iCatched = 1; continue; } if((rgnNodes[myID][v].iCatched==0 && rgnNodes[myID][v].iDist>(rgnNodes[myID][u].iDist+AdjMatrix[u][v]))){ rgnNodes[myID][v].iDist=rgnNodes[myID][u].iDist+AdjMatrix[u][v]; rgnNodes[myID][v].iPrev = u; } } uVertex[myID].iDist = NONE; //Reset } sendResult(myID,chStart,chEnd); qtdEnvios++; } Message msg; msg.length = 33; msg.msg[0] = -1; Send(msg, divider); //MADA ECHO("finaliza\n"); } int main(int argc, char *argv[]) { MemoryWrite(INITIALIZE_ROUTER, 156); int i, j; Message msg; msg.length = NUM_NODES*(NUM_NODES-1)/2; msg = Receive(); //MADAmsg, divider); for (i=0; i<(NUM_NODES*(NUM_NODES-1)/2); i++) nodes_tasks[i][0] = msg.msg[i]; msg = Receive(); //MADAmsg, divider); for (i=0; i<(NUM_NODES*(NUM_NODES-1)/2); i++) nodes_tasks[i][1] = msg.msg[i]; msg.length = MAXPROCESSORS; msg = Receive(); //MADAmsg, divider); for (i=0; i<MAXPROCESSORS; i++) { tasks[i][0] = msg.msg[i]; } msg = Receive(); //MADAmsg, divider); for (i=0; i<MAXPROCESSORS; i++) { tasks[i][1] = msg.msg[i]; } msg.length = NUM_NODES; for (i=0; i<NUM_NODES; i++) { msg = Receive(); //MADAmsg, divider); for (j=0; j<NUM_NODES; j++) AdjMatrix[j][i] = msg.msg[j]; } for(i=0; i<NUM_NODES; i++) { //MADA ECHO(" D1: "); for(j=0; j<NUM_NODES; j++) { //MADA ECHO(itoa(AdjMatrix[i][j])); //MADA ECHO(" "); } //MADA ECHO("\n"); } dijkstra(rank); //MADA ECHO(itoa(GetTick())); printf("Dijkstra_155 finished."); MemoryWrite(END_SIM, 156); return 0; }

guimadalozzo@gmail.com

ef97a41500a17f4ce43d67ba9e7f8dd2f8a1ecea

9d305211900776052b21bd203d7f94c815f3d19d

/proc.c

fe7914b839816112a787cbec60f1d2d233fb0886

permissive

iDarkknight/COL331_XV6

c5b6ed69ceea0887cc30e5fafad47c24e7ba6959

ab041fb7fa40653e300e02404f7bf894b43e3990

refs/heads/master

UTF-8

C

c

#include "types.h" #include "defs.h" #include "param.h" #include "memlayout.h" #include "mmu.h" #include "x86.h" #include "proc.h" #include "spinlock.h" struct { struct spinlock lock; struct proc proc[NPROC]; } ptable; static struct proc *initproc; int nextpid = 1; extern void forkret(void); extern void trapret(void); static void wakeup1(void *chan); void pinit(void) { initlock(&ptable.lock, "ptable"); } // Must be called with interrupts disabled int cpuid() { return mycpu()-cpus; } // Must be called with interrupts disabled to avoid the caller being // rescheduled between reading lapicid and running through the loop. struct cpu* mycpu(void) { int apicid, i; if(readeflags()&FL_IF) panic("mycpu called with interrupts enabled\n"); apicid = lapicid(); // APIC IDs are not guaranteed to be contiguous. Maybe we should have // a reverse map, or reserve a register to store &cpus[i]. for (i = 0; i < ncpu; ++i) { if (cpus[i].apicid == apicid) return &cpus[i]; } panic("unknown apicid\n"); } // Disable interrupts so that we are not rescheduled // while reading proc from the cpu structure struct proc* myproc(void) { struct cpu *c; struct proc *p; pushcli(); c = mycpu(); p = c->proc; popcli(); return p; } //PAGEBREAK: 32 // Look in the process table for an UNUSED proc. // If found, change state to EMBRYO and initialize // state required to run in the kernel. // Otherwise return 0. static struct proc* allocproc(void) { struct proc *p; char *sp; acquire(&ptable.lock); for(p = ptable.proc; p < &ptable.proc[NPROC]; p++) if(p->state == UNUSED) goto found; release(&ptable.lock); return 0; found: p->state = EMBRYO; p->pid = nextpid++; release(&ptable.lock); // Allocate kernel stack. if((p->kstack = kalloc()) == 0){ p->state = UNUSED; return 0; } sp = p->kstack + KSTACKSIZE; // Leave room for trap frame. sp -= sizeof *p->tf; p->tf = (struct trapframe*)sp; // Set up new context to start executing at forkret, // which returns to trapret. sp -= 4; *(uint*)sp = (uint)trapret; sp -= sizeof *p->context; p->context = (struct context*)sp; memset(p->context, 0, sizeof *p->context); p->context->eip = (uint)forkret; return p; } //PAGEBREAK: 32 // Set up first user process. void userinit(void) { struct proc *p; extern char _binary_initcode_start[], _binary_initcode_size[]; p = allocproc(); initproc = p; if((p->pgdir = setupkvm()) == 0) panic("userinit: out of memory?"); inituvm(p->pgdir, _binary_initcode_start, (int)_binary_initcode_size); p->sz = PGSIZE; memset(p->tf, 0, sizeof(*p->tf)); p->tf->cs = (SEG_UCODE << 3) | DPL_USER; p->tf->ds = (SEG_UDATA << 3) | DPL_USER; p->tf->es = p->tf->ds; p->tf->ss = p->tf->ds; p->tf->eflags = FL_IF; p->tf->esp = PGSIZE; p->tf->eip = 0; // beginning of initcode.S safestrcpy(p->name, "initcode", sizeof(p->name)); p->cwd = namei("/"); // this assignment to p->state lets other cores // run this process. the acquire forces the above // writes to be visible, and the lock is also needed // because the assignment might not be atomic. acquire(&ptable.lock); p->state = RUNNABLE; release(&ptable.lock); } // Grow current process's memory by n bytes. // Return 0 on success, -1 on failure. int growproc(int n) { uint sz; struct proc *curproc = myproc(); sz = curproc->sz; if(n > 0){ if((sz = allocuvm(curproc->pgdir, sz, sz + n)) == 0) return -1; } else if(n < 0){ if((sz = deallocuvm(curproc->pgdir, sz, sz + n)) == 0) return -1; } curproc->sz = sz; switchuvm(curproc); return 0; } // Create a new process copying p as the parent. // Sets up stack to return as if from system call. // Caller must set state of returned proc to RUNNABLE. int fork(void) { int i, pid; struct proc *np; struct proc *curproc = myproc(); // Allocate process. if((np = allocproc()) == 0){ return -1; } // Copy process state from proc. if((np->pgdir = copyuvm(curproc->pgdir, curproc->sz)) == 0){ kfree(np->kstack); np->kstack = 0; np->state = UNUSED; return -1; } np->sz = curproc->sz; np->parent = curproc; *np->tf = *curproc->tf; // Clear %eax so that fork returns 0 in the child. np->tf->eax = 0; for(i = 0; i < NOFILE; i++) if(curproc->ofile[i]) np->ofile[i] = filedup(curproc->ofile[i]); np->cwd = idup(curproc->cwd); safestrcpy(np->name, curproc->name, sizeof(curproc->name)); pid = np->pid; acquire(&ptable.lock); np->state = RUNNABLE; release(&ptable.lock); return pid; } // Exit the current process. Does not return. // An exited process remains in the zombie state // until its parent calls wait() to find out it exited. void exit(void) { struct proc *curproc = myproc(); struct proc *p; int fd; if(curproc == initproc) panic("init exiting"); // Close all open files. for(fd = 0; fd < NOFILE; fd++){ if(curproc->ofile[fd]){ fileclose(curproc->ofile[fd]); curproc->ofile[fd] = 0; } } begin_op(); iput(curproc->cwd); end_op(); curproc->cwd = 0; acquire(&ptable.lock); // Parent might be sleeping in wait(). wakeup1(curproc->parent); // Pass abandoned children to init. for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ if(p->parent == curproc){ p->parent = initproc; if(p->state == ZOMBIE) wakeup1(initproc); } } // Jump into the scheduler, never to return. curproc->state = ZOMBIE; sched(); panic("zombie exit"); } // Wait for a child process to exit and return its pid. // Return -1 if this process has no children. int wait(void) { struct proc *p; int havekids, pid; struct proc *curproc = myproc(); acquire(&ptable.lock); for(;;){ // Scan through table looking for exited children. havekids = 0; for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ if(p->parent != curproc) continue; havekids = 1; if(p->state == ZOMBIE){ // Found one. pid = p->pid; kfree(p->kstack); p->kstack = 0; freevm(p->pgdir); p->pid = 0; p->parent = 0; p->name[0] = 0; p->killed = 0; p->state = UNUSED; release(&ptable.lock); return pid; } } // No point waiting if we don't have any children. if(!havekids || curproc->killed){ release(&ptable.lock); return -1; } // Wait for children to exit. (See wakeup1 call in proc_exit.) sleep(curproc, &ptable.lock); //DOC: wait-sleep } } //PAGEBREAK: 42 // Per-CPU process scheduler. // Each CPU calls scheduler() after setting itself up. // Scheduler never returns. It loops, doing: // - choose a process to run // - swtch to start running that process // - eventually that process transfers control // via swtch back to the scheduler. void scheduler(void) { struct proc *p; struct cpu *c = mycpu(); c->proc = 0; for(;;){ // Enable interrupts on this processor. sti(); // Loop over process table looking for process to run. acquire(&ptable.lock); for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ if(p->state != RUNNABLE) continue; // Switch to chosen process. It is the process's job // to release ptable.lock and then reacquire it // before jumping back to us. c->proc = p; switchuvm(p); p->state = RUNNING; swtch(&(c->scheduler), p->context); switchkvm(); // Process is done running for now. // It should have changed its p->state before coming back. c->proc = 0; } release(&ptable.lock); } } // Enter scheduler. Must hold only ptable.lock // and have changed proc->state. Saves and restores // intena because intena is a property of this // kernel thread, not this CPU. It should // be proc->intena and proc->ncli, but that would // break in the few places where a lock is held but // there's no process. void sched(void) { int intena; struct proc *p = myproc(); if(!holding(&ptable.lock)) panic("sched ptable.lock"); if(mycpu()->ncli != 1) panic("sched locks"); if(p->state == RUNNING) panic("sched running"); if(readeflags()&FL_IF) panic("sched interruptible"); intena = mycpu()->intena; swtch(&p->context, mycpu()->scheduler); mycpu()->intena = intena; } // Give up the CPU for one scheduling round. void yield(void) { acquire(&ptable.lock); //DOC: yieldlock myproc()->state = RUNNABLE; sched(); release(&ptable.lock); } // A fork child's very first scheduling by scheduler() // will swtch here. "Return" to user space. void forkret(void) { static int first = 1; // Still holding ptable.lock from scheduler. release(&ptable.lock); if (first) { // Some initialization functions must be run in the context // of a regular process (e.g., they call sleep), and thus cannot // be run from main(). first = 0; iinit(ROOTDEV); initlog(ROOTDEV); } // Return to "caller", actually trapret (see allocproc). } // Atomically release lock and sleep on chan. // Reacquires lock when awakened. void sleep(void *chan, struct spinlock *lk) { struct proc *p = myproc(); if(p == 0) panic("sleep"); if(lk == 0) panic("sleep without lk"); // Must acquire ptable.lock in order to // change p->state and then call sched. // Once we hold ptable.lock, we can be // guaranteed that we won't miss any wakeup // (wakeup runs with ptable.lock locked), // so it's okay to release lk. if(lk != &ptable.lock){ //DOC: sleeplock0 acquire(&ptable.lock); //DOC: sleeplock1 release(lk); } // Go to sleep. p->chan = chan; p->state = SLEEPING; sched(); // Tidy up. p->chan = 0; // Reacquire original lock. if(lk != &ptable.lock){ //DOC: sleeplock2 release(&ptable.lock); acquire(lk); } } //PAGEBREAK! // Wake up all processes sleeping on chan. // The ptable lock must be held. static void wakeup1(void *chan) { struct proc *p; for(p = ptable.proc; p < &ptable.proc[NPROC]; p++) if(p->state == SLEEPING && p->chan == chan) p->state = RUNNABLE; } // Wake up all processes sleeping on chan. void wakeup(void *chan) { acquire(&ptable.lock); wakeup1(chan); release(&ptable.lock); } // Kill the process with the given pid. // Process won't exit until it returns // to user space (see trap in trap.c). int kill(int pid) { struct proc *p; acquire(&ptable.lock); for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ if(p->pid == pid){ p->killed = 1; // Wake process from sleep if necessary. if(p->state == SLEEPING) p->state = RUNNABLE; release(&ptable.lock); return 0; } } release(&ptable.lock); return -1; } //PAGEBREAK: 36 // Print a process listing to console. For debugging. // Runs when user types ^P on console. // No lock to avoid wedging a stuck machine further. void procdump(void) { static char *states[] = { [UNUSED] "unused", [EMBRYO] "embryo", [SLEEPING] "sleep ", [RUNNABLE] "runble", [RUNNING] "run ", [ZOMBIE] "zombie" }; int i; struct proc *p; char *state; uint pc[10]; for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ if(p->state == UNUSED) continue; if(p->state >= 0 && p->state < NELEM(states) && states[p->state]) state = states[p->state]; else state = "???"; cprintf("%d %s %s", p->pid, state, p->name); if(p->state == SLEEPING){ getcallerpcs((uint*)p->context->ebp+2, pc); for(i=0; i<10 && pc[i] != 0; i++) cprintf(" %p", pc[i]); } cprintf("\n"); } } //My EDIT 1 /*My Procdump*/ void myprocdump(void) { struct proc *p; for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ if(p->state == UNUSED ||p->state == EMBRYO || p->state == ZOMBIE ) continue; cprintf("pid:%d name:%s", p->pid, p->name); cprintf("\n"); } } //My EDIT 1

sourabh.basuthkar@gmail.com

41419c1ec6e2bf9e72e330cf9f9eb35229ab7287

16caae4586ae492d6e5f1e0a2abd3bcbc9fcbd18

/ChattingServer_v1.1/StressServer/Packet.h

496c31f51403c14cff82775b80fb1f4d4a9194d6

no_license

mingdyuo/TCP-socket-chatting-server

98e5e074fa655230b541d4955ed03dbf1d571ddf

98c40617bdf6d14a7cad24e6ccee4c700bd9ddee

refs/heads/main

C++

UTF-8

C

h

#pragma once #include <windows.h> #ifndef _STRUCT_PACKET #define _STRUCT_PACKET enum eAction : UINT16 { UNINITIALIZED = 0, SERVER_ENTER = 11, SERVER_EXIT = 12, ROOM_ENTER = 21, ROOM_EXIT = 22, CHAT_BROADCAST = 31, CHAT_MULTICAST = 32, CHAT_UNICAST = 33, LIST_CURRENT_ROOM = 41, LIST_ALL_ROOM = 42, LIST_LOBBY = 43, SERVER_MESSAGE = 51, }; enum eMessage : UINT32 { NICKNAME_ALREADY_EXIST = 1, NICKNAME_CREATED, NICKNAME_NOT_FOUND, }; #pragma pack(push, 1) struct PACKET_HEADER { UINT16 Length; UINT16 Type; }; const UINT32 PACKET_HEADER_LENGTH = sizeof(PACKET_HEADER); const int MAX_NICKNAME_LEN = 32; const int MAX_CONTENT_LEN = 900; typedef struct SYSTEM_PACKET : public PACKET_HEADER { char Sender[MAX_NICKNAME_LEN]; }ROOM_EXIT_PACKET, SERVER_ENTER_PACKET, SERVER_EXIT_PACKET; struct ROOM_ENTER_PACKET : public SYSTEM_PACKET { int RoomNo; }; const int ROOM_ENTER_PACKET_LENGTH = sizeof(ROOM_ENTER_PACKET); typedef struct CHAT_PACKET : public PACKET_HEADER { char Sender[MAX_NICKNAME_LEN]; char Content[MAX_CONTENT_LEN]; }MULTICAST_PACKET, BROADCAST_PACKET; const int CHAT_PACKET_LENGTH = sizeof(CHAT_PACKET); struct UNICAST_PACKET : public PACKET_HEADER { char Recver[MAX_NICKNAME_LEN]; char Sender[MAX_NICKNAME_LEN]; char Content[MAX_CONTENT_LEN]; }; const int UNICAST_BASE_LENGTH = MAX_NICKNAME_LEN * 2 + PACKET_HEADER_LENGTH; struct SERVER_MESSAGE_PACKET : public PACKET_HEADER { UINT32 Message; }; const int SERVER_MESSAGE_PACKET_LENGTH = sizeof(SERVER_MESSAGE_PACKET); #pragma pack(pop) #endif

phera5432@naver.com

df2572158eaf64e3e635be18d04e26bcf6d5306c

9ef7736ef3efb7c801208fc9d5de8c3b74e75362

/src/ds1963s-emulator-yaml.c

f5b847f4d6cf2968745062bde3bc685505c9e1fb

no_license

rhuizer/ds1963s-utils

dc7567811bfc92dabcf5b55dedbb86fa4a860dc5

29eaff8a9b6390139427253c9203cf7cd960a93f

refs/heads/master

UTF-8

C

c

/* ds1963s-emulator-yaml.c * * Parse a yaml configuration defining the ds1963s ibutton to emulate. * * Dedicated to Yuzuyu Arielle Huizer. * * Not a fan of libyaml in C, this code is a horribly convoluted state machine. * Either I've gotten the use wrong, or the design of libyaml is bad. Instead * of saving time and work it wasted and created it, which is the opposite of * what a good library is supposed to do. * * Copyright (C) 2016-2019 Ronald Huizer <rhuizer@hexpedition.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 3 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, see <https://www.gnu.org/licenses/>. */ #include <ctype.h> #include <yaml.h> #include "ds1963s-common.h" #include "ds1963s-device.h" #define STATE_INIT 0 #define STATE_DOCUMENT 1 #define STATE_GLOBAL_MAP 2 #define STATE_KEY 3 #define STATE_FAMILY 4 #define STATE_SERIAL 5 #define STATE_CRC8 6 #define STATE_PRNG_COUNTER 7 #define STATE_WRITE_CYCLE_MAP 8 #define STATE_WRITE_CYCLE_KEY 9 #define STATE_WRITE_CYCLE_VALUE 10 #define STATE_NVRAM_MAP 11 #define STATE_NVRAM_KEY 12 #define STATE_NVRAM_VALUE 13 #define STATE_SECRET_MAP 14 #define STATE_SECRET_KEY 15 #define STATE_SECRET_VALUE 16 #define STATE_DOCUMENT_END 17 #define STATE_STREAM_END 18 #define SEEN_FAMILY 1 #define SEEN_SERIAL 2 #define SEEN_CRC8 4 #define SEEN_PRNG_COUNTER 8 #define SEEN_SECRET 16 #define SEEN_WRITE_CYCLE 32 #define SEEN_NVRAM 64 #define SEEN_ALL 127 struct parser_context { yaml_parser_t parser; yaml_event_t event; int state; uint16_t key_seen; uint8_t family; uint8_t serial[6]; uint32_t prng_counter; uint32_t * wcp; uint16_t wc_seen; uint32_t data_wc[8]; uint32_t secret_wc[8]; uint8_t * nvp; uint16_t nvram_seen; uint8_t nvram[512]; uint8_t * sp; uint8_t secret_seen; uint8_t secret[64]; }; static void __parser_init(struct parser_context *ctx, FILE *fp) { memset(ctx, 0, sizeof *ctx); yaml_parser_initialize(&ctx->parser); yaml_parser_set_input_file(&ctx->parser, fp); ctx->state = STATE_INIT; } static void __parser_error(struct parser_context *ctx) { assert(ctx != NULL); fprintf(stderr, "Parse error %d: %s\n", ctx->parser.error, ctx->parser.problem); yaml_parser_delete(&ctx->parser); exit(EXIT_FAILURE); } static void __parser_parse(struct parser_context *ctx) { if (yaml_parser_parse(&ctx->parser, &ctx->event) == -1) __parser_error(ctx); } static void __yaml_key_error(yaml_parser_t *parser, const char *key) { fprintf(stderr, "Parse error: unknown key `%s'.\n", key); yaml_parser_delete(parser); exit(EXIT_FAILURE); } static unsigned int __parse_int(yaml_parser_t *parser, const char *s) { char *endptr; int ret; if (*s == 0) { fprintf(stderr, "Parse error: empty value.\n"); yaml_parser_delete(parser); exit(EXIT_FAILURE); } ret = strtoul(s, &endptr, 16); if (*endptr != 0) { fprintf(stderr, "Parse error: invalid integer: `%s'\n", endptr); yaml_parser_delete(parser); exit(EXIT_FAILURE); } return ret; } static void __is_hex_string(yaml_parser_t *parser, const char *s) { for (; *s != 0; s++) { if (!isxdigit(*s)) { fprintf(stderr, "Parse error: invalid hex string: `%s'\n", s); yaml_parser_delete(parser); exit(EXIT_FAILURE); } } } static void __is_length(yaml_parser_t *parser, const char *s, size_t size) { if (strlen(s) != size) { fprintf(stderr, "Parse error: invalid length: `%s'. " "Expected %zu.\n", s, size); yaml_parser_delete(parser); exit(EXIT_FAILURE); } } static void __handle_init(struct parser_context *ctx) { assert(ctx != NULL); assert(ctx->state == STATE_INIT); if (ctx->event.type != YAML_STREAM_START_EVENT) { fprintf(stderr, "Expected start event.\n"); exit(EXIT_FAILURE); } ctx->state = STATE_DOCUMENT; } static void __handle_stream_end(struct parser_context *ctx) { assert(ctx != NULL); assert(ctx->state == STATE_STREAM_END); if (ctx->event.type != YAML_STREAM_END_EVENT) { fprintf(stderr, "Expected stream end event.\n"); exit(EXIT_FAILURE); } } static void __handle_global_map(struct parser_context *ctx) { assert(ctx != NULL); assert(ctx->state == STATE_GLOBAL_MAP); if (ctx->event.type != YAML_MAPPING_START_EVENT) { fprintf(stderr, "Expected map start event.\n"); exit(EXIT_FAILURE); } ctx->state = STATE_KEY; } static void __handle_global_key(struct parser_context *ctx) { const char *str; if (ctx->event.type == YAML_MAPPING_END_EVENT) { if (ctx->key_seen != SEEN_ALL) { fprintf(stderr, "Warning: not all keys have been " "defined.\n"); } ctx->state = STATE_DOCUMENT_END; return; } if (ctx->event.type != YAML_SCALAR_EVENT) { fprintf(stderr, "Expected scalar event.\n"); exit(EXIT_FAILURE); } str = (char *)ctx->event.data.scalar.value; if (strcmp(str, "family") == 0) ctx->state = STATE_FAMILY; else if (strcmp(str, "serial") == 0) ctx->state = STATE_SERIAL; else if (strcmp(str, "crc8") == 0) ctx->state = STATE_CRC8; else if (strcmp(str, "write_cycle_counters") == 0) ctx->state = STATE_WRITE_CYCLE_MAP; else if (strcmp(str, "nvram") == 0) ctx->state = STATE_NVRAM_MAP; else if (strcmp(str, "prng_counter") == 0) ctx->state = STATE_PRNG_COUNTER; else if (strcmp(str, "secrets") == 0) ctx->state = STATE_SECRET_MAP; else __yaml_key_error(&ctx->parser, str); } static void __handle_family(struct parser_context *ctx) { const char *str; if (ctx->event.type != YAML_SCALAR_EVENT) { fprintf(stderr, "Expected scalar event.\n"); exit(EXIT_FAILURE); } str = (char *)ctx->event.data.scalar.value; ctx->family = __parse_int(&ctx->parser, str); ctx->state = STATE_KEY; ctx->key_seen |= SEEN_FAMILY; } static void __handle_serial(struct parser_context *ctx) { const char *str; if (ctx->event.type != YAML_SCALAR_EVENT) { fprintf(stderr, "Expected scalar event.\n"); exit(EXIT_FAILURE); } str = (char *)ctx->event.data.scalar.value; __is_hex_string(&ctx->parser, str); __is_length(&ctx->parser, str, sizeof(ctx->serial) * 2); hex_decode(ctx->serial, str, sizeof ctx->serial); ctx->state = STATE_KEY; ctx->key_seen |= SEEN_SERIAL; } static void __handle_prng(struct parser_context *ctx) { const char *str; if (ctx->event.type != YAML_SCALAR_EVENT) { fprintf(stderr, "Expected scalar event.\n"); exit(EXIT_FAILURE); } str = (char *)ctx->event.data.scalar.value; ctx->prng_counter = __parse_int(&ctx->parser, str); ctx->state = STATE_KEY; ctx->key_seen |= SEEN_PRNG_COUNTER; } static void __handle_document(struct parser_context *ctx) { assert(ctx != NULL); assert(ctx->state == STATE_DOCUMENT); if (ctx->event.type != YAML_DOCUMENT_START_EVENT) { fprintf(stderr, "Expected start event.\n"); exit(EXIT_FAILURE); } ctx->state = STATE_GLOBAL_MAP; } static void __handle_document_end(struct parser_context *ctx) { assert(ctx != NULL); assert(ctx->state == STATE_DOCUMENT_END); if (ctx->event.type != YAML_DOCUMENT_END_EVENT) { fprintf(stderr, "Expected document end event.\n"); exit(EXIT_FAILURE); } ctx->state = STATE_STREAM_END; } static void __handle_write_cycle_map(struct parser_context *ctx) { assert(ctx != NULL); assert(ctx->state == STATE_WRITE_CYCLE_MAP); if (ctx->event.type != YAML_MAPPING_START_EVENT) { fprintf(stderr, "Expected start event.\n"); exit(EXIT_FAILURE); } ctx->state = STATE_WRITE_CYCLE_KEY; } static void __handle_write_cycle_key(struct parser_context *ctx) { unsigned int i; const char *s; char *endptr; assert(ctx != NULL); assert(ctx->state == STATE_WRITE_CYCLE_KEY); if (ctx->event.type == YAML_MAPPING_END_EVENT) { if (ctx->wc_seen != 0xFFFF) { fprintf(stderr, "Warning: not all write cycle " "counters have been defined.\n"); } ctx->state = STATE_KEY; return; } if (ctx->event.type != YAML_SCALAR_EVENT) { fprintf(stderr, "Expected scalar event.\n"); exit(EXIT_FAILURE); } s = (char *)ctx->event.data.scalar.value; if (!strncmp(s, "data_page_", 10) && s[10] != 0) { i = strtoul(&s[10], &endptr, 10); if (*endptr != 0 || i < 8 || i > 15) goto error; if (ctx->wc_seen & (i << i)) { fprintf(stderr, "Warning: redefined write cycle " "counter `%s'.\n", s); } ctx->wc_seen |= 1 << i; ctx->wcp = &ctx->data_wc[i - 8]; ctx->state = STATE_WRITE_CYCLE_VALUE; return; } if (!strncmp(s, "secret_", 7) && s[7] != 0) { i = strtoul(&s[7], &endptr, 10); if (*endptr != 0 || i > 7) goto error; ctx->wc_seen |= 1 << i; ctx->wcp = &ctx->secret_wc[i]; ctx->state = STATE_WRITE_CYCLE_VALUE; return; } error: fprintf(stderr, "Parse error: unknown write-cycle key `%s'.\n", s); yaml_parser_delete(&ctx->parser); exit(EXIT_FAILURE); } static void __handle_write_cycle_value(struct parser_context *ctx) { const char *str; assert(ctx != NULL); assert(ctx->state == STATE_WRITE_CYCLE_VALUE); if (ctx->event.type != YAML_SCALAR_EVENT) { fprintf(stderr, "Expected scalar event.\n"); exit(EXIT_FAILURE); } str = (char *)ctx->event.data.scalar.value; *ctx->wcp = __parse_int(&ctx->parser, str); ctx->state = STATE_WRITE_CYCLE_KEY; } static void __handle_nvram_map(struct parser_context *ctx) { assert(ctx != NULL); assert(ctx->state == STATE_NVRAM_MAP); if (ctx->event.type != YAML_MAPPING_START_EVENT) { fprintf(stderr, "Expected start event.\n"); exit(EXIT_FAILURE); } ctx->state = STATE_NVRAM_KEY; } static void __handle_nvram_key(struct parser_context *ctx) { unsigned int i; const char *s; char *endptr; assert(ctx != NULL); assert(ctx->state == STATE_NVRAM_KEY); if (ctx->event.type == YAML_MAPPING_END_EVENT) { if (ctx->nvram_seen != 0xFFFF) { fprintf(stderr, "Warning: not all nvram pages " "have been defined.\n"); } ctx->state = STATE_KEY; return; } if (ctx->event.type != YAML_SCALAR_EVENT) { fprintf(stderr, "Expected scalar event.\n"); exit(EXIT_FAILURE); } s = (char *)ctx->event.data.scalar.value; if (!strncmp(s, "page_", 5) && s[5] != 0) { i = strtoul(&s[5], &endptr, 10); if (*endptr != 0 || i > 15) goto error; if (ctx->nvram_seen & (i << i)) { fprintf(stderr, "Warning: redefined nvram " "page `%s'.\n", s); } ctx->nvram_seen |= 1 << i; ctx->nvp = &ctx->nvram[i * 32]; ctx->state = STATE_NVRAM_VALUE; return; } error: fprintf(stderr, "Parse error: unknown nvram key `%s'.\n", s); yaml_parser_delete(&ctx->parser); exit(EXIT_FAILURE); } static void __handle_nvram_value(struct parser_context *ctx) { const char *str; assert(ctx != NULL); assert(ctx->state == STATE_NVRAM_VALUE); if (ctx->event.type != YAML_SCALAR_EVENT) { fprintf(stderr, "Expected scalar event.\n"); exit(EXIT_FAILURE); } str = (char *)ctx->event.data.scalar.value; __is_hex_string(&ctx->parser, str); __is_length(&ctx->parser, str, 64); hex_decode(ctx->nvp, str, 32); ctx->state = STATE_NVRAM_KEY; } static void __handle_secret_map(struct parser_context *ctx) { assert(ctx != NULL); assert(ctx->state == STATE_SECRET_MAP); if (ctx->event.type != YAML_MAPPING_START_EVENT) { fprintf(stderr, "Expected start event.\n"); exit(EXIT_FAILURE); } ctx->state = STATE_SECRET_KEY; } static void __handle_secret_key(struct parser_context *ctx) { unsigned int i; const char *s; char *endptr; assert(ctx != NULL); assert(ctx->state == STATE_SECRET_KEY); if (ctx->event.type == YAML_MAPPING_END_EVENT) { if (ctx->secret_seen != 0xFF) { fprintf(stderr, "Warning: not all secrets " "have been defined.\n"); } ctx->state = STATE_KEY; return; } if (ctx->event.type != YAML_SCALAR_EVENT) { fprintf(stderr, "Expected scalar event.\n"); exit(EXIT_FAILURE); } s = (char *)ctx->event.data.scalar.value; if (!strncmp(s, "secret_", 7) && s[7] != 0) { i = strtoul(&s[7], &endptr, 10); if (*endptr != 0 || i > 7) goto error; if (ctx->secret_seen & (i << i)) { fprintf(stderr, "Warning: redefined secret " "`%s'.\n", s); } ctx->secret_seen |= 1 << i; ctx->sp = &ctx->secret[i * 8]; ctx->state = STATE_SECRET_VALUE; return; } error: fprintf(stderr, "Parse error: unknown nvram key `%s'.\n", s); yaml_parser_delete(&ctx->parser); exit(EXIT_FAILURE); } static void __handle_secret_value(struct parser_context *ctx) { const char *str; assert(ctx != NULL); assert(ctx->state == STATE_SECRET_VALUE); if (ctx->event.type != YAML_SCALAR_EVENT) { fprintf(stderr, "Expected scalar event.\n"); exit(EXIT_FAILURE); } str = (char *)ctx->event.data.scalar.value; __is_hex_string(&ctx->parser, str); __is_length(&ctx->parser, str, 16); hex_decode(ctx->sp, str, 8); ctx->state = STATE_SECRET_KEY; } int ds1963s_emulator_yaml_load(struct ds1963s_device *dev, const char *pathname) { struct parser_context ctx; FILE *fp; if ( (fp = fopen(pathname, "r")) == NULL) { perror("fopen()"); exit(EXIT_FAILURE); } __parser_init(&ctx, fp); do { __parser_parse(&ctx); switch (ctx.state) { case STATE_INIT: __handle_init(&ctx); break; case STATE_DOCUMENT: __handle_document(&ctx); break; case STATE_GLOBAL_MAP: __handle_global_map(&ctx); break; case STATE_KEY: __handle_global_key(&ctx); break; case STATE_FAMILY: __handle_family(&ctx); break; case STATE_SERIAL: __handle_serial(&ctx); break; case STATE_CRC8: /* XXX: ignore for now; we calculate it. */ ctx.state = STATE_KEY; ctx.key_seen |= SEEN_CRC8; break; case STATE_PRNG_COUNTER: __handle_prng(&ctx); break; case STATE_WRITE_CYCLE_MAP: __handle_write_cycle_map(&ctx); ctx.key_seen |= SEEN_WRITE_CYCLE; break; case STATE_WRITE_CYCLE_KEY: __handle_write_cycle_key(&ctx); break; case STATE_WRITE_CYCLE_VALUE: __handle_write_cycle_value(&ctx); break; case STATE_NVRAM_MAP: __handle_nvram_map(&ctx); ctx.key_seen |= SEEN_NVRAM; break; case STATE_NVRAM_KEY: __handle_nvram_key(&ctx); break; case STATE_NVRAM_VALUE: __handle_nvram_value(&ctx); break; case STATE_SECRET_MAP: __handle_secret_map(&ctx); ctx.key_seen |= SEEN_SECRET; break; case STATE_SECRET_KEY: __handle_secret_key(&ctx); break; case STATE_SECRET_VALUE: __handle_secret_value(&ctx); break; case STATE_DOCUMENT_END: __handle_document_end(&ctx); break; case STATE_STREAM_END: __handle_stream_end(&ctx); break; default: fprintf(stderr, "unknown state: %d\n", ctx.state); abort(); } } while (ctx.event.type != YAML_STREAM_END_EVENT); fclose(fp); dev->family = ctx.family; dev->prng_counter = ctx.prng_counter; memcpy(dev->data_wc, ctx.data_wc, sizeof dev->data_wc); memcpy(dev->secret_wc, ctx.secret_wc, sizeof dev->secret_wc); memcpy(dev->data_memory, ctx.nvram, sizeof dev->data_memory); memcpy(dev->secret_memory, ctx.secret, sizeof dev->secret_memory); /* Serial is a special case, as it is stored LSB first. For * presentation it has been reversed, so do this here too. */ for (int i = 0; i < sizeof dev->serial; i++) dev->serial[i] = ctx.serial[sizeof(ctx.serial) - 1 - i]; return 0; }

rhuizer@hexpedition.com

68a2a4953c14e165cff31300dc8cb149db9e7772

5a47737f5cc00543cb01f5bbb3e2f41e5f13b7ce

/teensyMAMEClassic1/_unused/drivers/driver_sonson.c

32c30e599b74eb14f1528f2e8961bdc041b4f0a1

no_license

Jean-MarcHarvengt/teensyMAME

0556df1a514e94e00706988f44e2e05b99f6971a

c4210da674aa72dd5e60be88a858812648e03fe9

refs/heads/master

UTF-8

C

c

/*************************************************************************** Son Son memory map (preliminary) MAIN CPU: 0000-0fff RAM 1000-13ff Video RAM 1400-17ff Color RAM 2020-207f Sprites 4000-ffff ROM read: 3002 IN0 3003 IN1 3004 IN2 3005 DSW0 3006 DSW1 see the input_ports definition below for details on the input bits write: 3000 horizontal scroll 3008 ? one of these two should be 3018 ? the watchdog reset 3010 command for the audio CPU 3019 trigger FIRQ on audio CPU SOUND CPU: 0000-07ff RAM e000-ffff ROM read: a000 command from the main CPU write: 2000 8910 #1 control 2001 8910 #1 write 4000 8910 #2 control 4001 8910 #2 write ***************************************************************************/ #include "driver.h" #include "vidhrdw/generic.h" #include "M6809/M6809.h" extern unsigned char *sonson_scrollx; void sonson_vh_convert_color_prom(unsigned char *palette, unsigned short *colortable,const unsigned char *color_prom); void sonson_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh); void sonson_init_machine(void) { /* Set optimization flags for M6809 */ m6809_Flags = M6809_FAST_S | M6809_FAST_U; } void sonson_sh_irqtrigger_w(int offset,int data) { static int last; if (last == 0 && data == 1) { /* setting bit 0 low then high triggers IRQ on the sound CPU */ cpu_cause_interrupt(1,M6809_INT_FIRQ); } last = data; } static struct MemoryReadAddress readmem[] = { { 0x0000, 0x17ff, MRA_RAM }, { 0x4000, 0xffff, MRA_ROM }, { 0x3002, 0x3002, input_port_0_r }, /* IN0 */ { 0x3003, 0x3003, input_port_1_r }, /* IN1 */ { 0x3004, 0x3004, input_port_2_r }, /* IN2 */ { 0x3005, 0x3005, input_port_3_r }, /* DSW0 */ { 0x3006, 0x3006, input_port_4_r }, /* DSW1 */ { -1 } /* end of table */ }; static struct MemoryWriteAddress writemem[] = { { 0x0000, 0x0fff, MWA_RAM }, { 0x1000, 0x13ff, videoram_w, &videoram, &videoram_size }, { 0x1400, 0x17ff, colorram_w, &colorram }, { 0x2020, 0x207f, MWA_RAM, &spriteram, &spriteram_size }, { 0x3000, 0x3000, MWA_RAM, &sonson_scrollx }, { 0x3008, 0x3008, MWA_NOP }, { 0x3010, 0x3010, soundlatch_w }, { 0x3018, 0x3018, MWA_NOP }, { 0x3019, 0x3019, sonson_sh_irqtrigger_w }, { 0x4000, 0xffff, MWA_ROM }, { -1 } /* end of table */ }; static struct MemoryReadAddress sound_readmem[] = { { 0x0000, 0x07ff, MRA_RAM }, { 0xa000, 0xa000, soundlatch_r }, { 0xe000, 0xffff, MRA_ROM }, { -1 } /* end of table */ }; static struct MemoryWriteAddress sound_writemem[] = { { 0x0000, 0x07ff, MWA_RAM }, { 0x2000, 0x2000, AY8910_control_port_0_w }, { 0x2001, 0x2001, AY8910_write_port_0_w }, { 0x4000, 0x4000, AY8910_control_port_1_w }, { 0x4001, 0x4001, AY8910_write_port_1_w }, { 0xe000, 0xffff, MWA_ROM }, { -1 } /* end of table */ }; INPUT_PORTS_START( input_ports ) PORT_START /* IN0 */ PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_UNKNOWN ) /* probably unused */ PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT | IPF_8WAY ) PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT | IPF_8WAY ) PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_JOYSTICK_UP | IPF_8WAY ) PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN | IPF_8WAY ) PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN ) /* probably unused */ PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN ) /* probably unused */ PORT_START /* IN1 */ PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_BUTTON1 | IPF_PLAYER2 ) PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_UNKNOWN ) /* probably unused */ PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT | IPF_8WAY | IPF_PLAYER2 ) PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT | IPF_8WAY | IPF_PLAYER2 ) PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_JOYSTICK_UP | IPF_8WAY | IPF_PLAYER2 ) PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN | IPF_8WAY | IPF_PLAYER2 ) PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN ) /* probably unused */ PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN ) /* probably unused */ PORT_START /* IN2 */ PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_START1 ) PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_START2 ) PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_UNKNOWN ) /* probably unused */ PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_UNKNOWN ) /* probably unused */ PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_COIN1 ) PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_COIN2 ) PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN ) /* probably unused */ PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN ) /* probably unused */ PORT_START /* DSW0 */ PORT_DIPNAME( 0x0f, 0x0f, "Coinage", IP_KEY_NONE ) PORT_DIPSETTING( 0x02, "4 Coins/1 Credit" ) PORT_DIPSETTING( 0x05, "3 Coins/1 Credit" ) PORT_DIPSETTING( 0x08, "2 Coins/1 Credit" ) PORT_DIPSETTING( 0x04, "3 Coins/2 Credits" ) PORT_DIPSETTING( 0x01, "4 Coins/3 Credits" ) PORT_DIPSETTING( 0x0f, "1 Coin/1 Credit" ) PORT_DIPSETTING( 0x03, "3 Coins/4 Credits" ) PORT_DIPSETTING( 0x07, "2 Coins/3 Credits" ) PORT_DIPSETTING( 0x0e, "1 Coin/2 Credits" ) PORT_DIPSETTING( 0x06, "2 Coins/5 Credits" ) PORT_DIPSETTING( 0x0d, "1 Coin/3 Credits" ) PORT_DIPSETTING( 0x0c, "1 Coin/4 Credits" ) PORT_DIPSETTING( 0x0b, "1 Coin/5 Credits" ) PORT_DIPSETTING( 0x0a, "1 Coin/6 Credits" ) PORT_DIPSETTING( 0x09, "1 Coin/7 Credits" ) PORT_DIPSETTING( 0x00, "Free Play" ) PORT_DIPNAME( 0x10, 0x10, "Coinage affects", IP_KEY_NONE ) PORT_DIPSETTING( 0x10, "Coin A" ) PORT_DIPSETTING( 0x00, "Coin B" ) PORT_DIPNAME( 0x20, 0x00, "Demo Sounds", IP_KEY_NONE ) PORT_DIPSETTING( 0x20, "Off" ) PORT_DIPSETTING( 0x00, "On" ) PORT_BITX( 0x40, 0x40, IPT_DIPSWITCH_NAME | IPF_TOGGLE, "Service Mode", OSD_KEY_F2, IP_JOY_NONE, 0 ) PORT_DIPSETTING( 0x40, "Off" ) PORT_DIPSETTING( 0x00, "On" ) PORT_DIPNAME( 0x80, 0x80, "unknown", IP_KEY_NONE ) /* maybe flip screen */ PORT_DIPSETTING( 0x80, "Off" ) PORT_DIPSETTING( 0x00, "On" ) PORT_START /* DSW1 */ PORT_DIPNAME( 0x03, 0x03, "Lives", IP_KEY_NONE ) PORT_DIPSETTING( 0x03, "3" ) PORT_DIPSETTING( 0x02, "4" ) PORT_DIPSETTING( 0x01, "5" ) PORT_DIPSETTING( 0x00, "7" ) PORT_DIPNAME( 0x04, 0x00, "2 Players Game", IP_KEY_NONE ) PORT_DIPSETTING( 0x04, "1 Credit" ) PORT_DIPSETTING( 0x00, "2 Credits" ) PORT_DIPNAME( 0x18, 0x08, "Bonus Life", IP_KEY_NONE ) PORT_DIPSETTING( 0x08, "20000 80000 100000" ) PORT_DIPSETTING( 0x00, "30000 90000 120000" ) PORT_DIPSETTING( 0x18, "20000" ) PORT_DIPSETTING( 0x10, "30000" ) PORT_DIPNAME( 0x60, 0x60, "Difficulty", IP_KEY_NONE ) PORT_DIPSETTING( 0x60, "Easy" ) PORT_DIPSETTING( 0x40, "Medium" ) PORT_DIPSETTING( 0x20, "Hard" ) PORT_DIPSETTING( 0x00, "Hardest" ) PORT_DIPNAME( 0x80, 0x80, "Freeze", IP_KEY_NONE ) PORT_DIPSETTING( 0x80, "Off" ) PORT_DIPSETTING( 0x00, "On" ) INPUT_PORTS_END static struct GfxLayout charlayout = { 8,8, /* 8*8 characters */ 1024, /* 1024 characters */ 2, /* 2 bits per pixel */ { 1024*8*8, 0 }, /* the two bitplanes are separated */ { 0, 1, 2, 3, 4, 5, 6, 7 }, /* pretty straightforward layout */ { 0*8, 1*8, 2*8, 3*8, 4*8, 5*8, 6*8, 7*8 }, 8*8 /* every char takes 8 consecutive bytes */ }; static struct GfxLayout spritelayout = { 16,16, /* 16*16 sprites */ 512, /* 512 sprites */ 3, /* 3 bits per pixel */ { 2*2048*8*8, 2048*8*8, 0 }, /* the two bitplanes are separated */ { 8*16+7, 8*16+6, 8*16+5, 8*16+4, 8*16+3, 8*16+2, 8*16+1, 8*16+0, /* pretty straightforward layout */ 7, 6, 5, 4, 3, 2, 1, 0 }, { 0*8, 1*8, 2*8, 3*8, 4*8, 5*8, 6*8, 7*8, 8*8, 9*8, 10*8, 11*8, 12*8, 13*8, 14*8, 15*8 }, 32*8 /* every sprite takes 32 consecutive bytes */ }; static struct GfxDecodeInfo gfxdecodeinfo[] = { { 1, 0x00000, &charlayout, 0, 64 }, { 1, 0x04000, &spritelayout, 64*4, 32 }, { -1 } /* end of array */ }; static struct AY8910interface ay8910_interface = { 2, /* 2 chips */ 1500000, /* 1.5 MHz ? */ { 0x10ff, 255 }, { 0 }, { 0 }, { 0 }, { 0 } }; static struct MachineDriver machine_driver = { /* basic machine hardware */ { { CPU_M6809, 2000000, /* 2 Mhz (?) */ 0, readmem,writemem,0,0, interrupt,1 }, { CPU_M6809 | CPU_AUDIO_CPU, 2000000, /* 2 Mhz (?) */ 3, sound_readmem,sound_writemem,0,0, interrupt,4 /* FIRQs are triggered by the main CPU */ }, }, 60, DEFAULT_60HZ_VBLANK_DURATION, /* frames per second, vblank duration */ 1, /* 1 CPU slice per frame - interleaving is forced when a sound command is written */ sonson_init_machine, /* video hardware */ 32*8, 32*8, { 1*8, 31*8-1, 1*8, 31*8-1 }, gfxdecodeinfo, 32,64*4+32*8, sonson_vh_convert_color_prom, VIDEO_TYPE_RASTER, 0, generic_vh_start, generic_vh_stop, sonson_vh_screenrefresh, /* sound hardware */ 0,0,0,0, { { SOUND_AY8910, &ay8910_interface } } }; /*************************************************************************** Game driver(s) ***************************************************************************/ ROM_START( sonson_rom ) ROM_REGION(0x10000) /* 64k for code + 3*16k for the banked ROMs images */ ROM_LOAD( "ss.01e", 0x4000, 0x4000, 0xcd40cc54 ) ROM_LOAD( "ss.02e", 0x8000, 0x4000, 0xc3476527 ) ROM_LOAD( "ss.03e", 0xc000, 0x4000, 0x1fd0e729 ) ROM_REGION_DISPOSE(0x10000) /* temporary space for graphics (disposed after conversion) */ ROM_LOAD( "ss5.v12", 0x00000, 0x2000, 0x990890b1 ) /* characters */ ROM_LOAD( "ss6.v12", 0x02000, 0x2000, 0x9388ff82 ) ROM_LOAD( "ss7.v12", 0x04000, 0x4000, 0x32b14b8e ) /* sprites */ ROM_LOAD( "ss8.v12", 0x08000, 0x4000, 0x9f59014e ) ROM_LOAD( "ss9.v12", 0x0c000, 0x4000, 0xe240345a ) ROM_REGION(0x0240) /* color PROMs */ ROM_LOAD( "ss12.bin", 0x0000, 0x0020, 0xc8eaf234 ) /* red/green component */ ROM_LOAD( "ss13.bin", 0x0020, 0x0020, 0x0e434add ) /* blue component */ ROM_LOAD( "ssb2.bin", 0x0040, 0x0100, 0x6ce8ac39 ) /* character lookup table */ ROM_LOAD( "ssb.bin", 0x0140, 0x0100, 0xd4f7bfb5 ) /* sprite lookup table */ ROM_REGION(0x10000) /* 64k for the audio CPU */ ROM_LOAD( "ss3.v12", 0xe000, 0x2000, 0x1135c48a ) ROM_END static int hiload(void) { unsigned char *RAM = Machine->memory_region[Machine->drv->cpu[0].memory_region]; /* check if the hi score table has already been initialized */ if (memcmp(&RAM[0x0300],"\x00\x01\x00\x00",4) == 0 && memcmp(&RAM[0x0320],"\x00\x01\x00\x00",4) == 0 && memcmp(&RAM[0x00d8],"\x00\x01\x00\x00",4) == 0 && /* high score */ memcmp(&RAM[0x0328],"\x00\x02\x00\x00",4) == 0 && memcmp(&RAM[0x0358],"\x00\x02\x00\x00",4) == 0) { void *f; if ((f = osd_fopen(Machine->gamedrv->name,0,OSD_FILETYPE_HIGHSCORE,0)) != 0) { osd_fread(f,&RAM[0x0300],8*5+12*5); RAM[0x00d8] = RAM[0x0300]; RAM[0x00d9] = RAM[0x0301]; RAM[0x00da] = RAM[0x0302]; RAM[0x00db] = RAM[0x0303]; osd_fclose(f); } return 1; } else return 0; /* we can't load the hi scores yet */ } static void hisave(void) { void *f; unsigned char *RAM = Machine->memory_region[Machine->drv->cpu[0].memory_region]; if ((f = osd_fopen(Machine->gamedrv->name,0,OSD_FILETYPE_HIGHSCORE,1)) != 0) { osd_fwrite(f,&RAM[0x0300],8*5+12*5); osd_fclose(f); } } struct GameDriver sonson_driver = { __FILE__, 0, "sonson", "Son Son", "1984", "Capcom", "Mirko Buffoni (MAME driver)\nNicola Salmoria (MAME driver)\nGary Walton (color info)\nSimon Walls (color info=", 0, &machine_driver, 0, sonson_rom, 0, 0, 0, 0, /* sound_prom */ input_ports, PROM_MEMORY_REGION(2), 0, 0, ORIENTATION_DEFAULT, hiload, hisave };

harvengtjeanmarc@gmail.com

be5467014fae4ef0c2d789cb8e5a9af419f723b5

07189bc64844260bc71268d29689b0b8d01f803d

/Appnote/W5200E01-M3_SMTP_with_DHCP/Work/App/source/APPs/dhcp.c

d530f368fc3786dc3418770b0981fc6309e404bf

no_license

KISSMonX/W7200

dd03400f615e05f53d9f61c1ea917bf519ef561b

61e1f8b782400a59c508b70571abe86113d6fa62

refs/heads/master