TempestTeam/dataset-the-stack-v2-dedup-sub

c9802e438483cc1d0dbde7a313a387eca5f06179

a1782ef8b19a1a2d07a9314dd2b02ba73b2144f4

/0x08-recursion/5-sqrt_recursion.c

a3912bba4688c4eba9364d3144036816d53bef08

[]

no_license

DiegoSusviela/holbertonschool-low_level_programming

e5d01edadecbc3505c288683622e4bfafabb1536

1805d346ecbbe560b6f0ff9b277afb5c75bbc10b

refs/heads/main

2023-07-19T04:37:24.501000

2021-09-02T01:31:42

335,614,488

0

null

UTF-8

C

false

561

c

5-sqrt_recursion.c

#include "holberton.h" /** * recursion - imprime * @n: numero a imprimir * @cand_root: un char ahi * * Description: Show a message blablabla * Return: Always 0 (Success) */ int recursion(int n, int cand_root) { int aux = cand_root * cand_root; if ((aux) < n) return (recursion(n, cand_root + 1)); if (aux == n) return (cand_root); else return (-1); } /** * _sqrt_recursion - imprime * @n: numero a imprimir * * Description: Show a message blablabla * Return: Always 0 (Success) */ int _sqrt_recursion(int n) { return (recursion(n, 0)); }

098e24bf8b8d78377c0a8fe5d7a860bbddc7dac0

5069aab5743db98be7692a438d0c59c1fb01fa28

/Core/Inc/MPU_9255.h

b33c94acc3c41e9d6dd725d8ddcaf62291278b0a

[]

no_license

alone141/SRHEX

10495d06066111280ef6395cacbc6b4257a7b48e

de2cc27e6948539b8d4f672a86e1a433e0d504a0

refs/heads/main

2023-08-18T01:22:54.081000

2021-08-28T21:08:42

400,886,764

0

null

2021-09-13T18:15:03

2021-08-28T20:43:26

C

UTF-8

C

false

2,019

h

MPU_9255.h

/* * MPU_9255.h * * Created on: Jul 15, 2021 * Author: Meliksah Sagun * * Disclaimer: * This is a free software under the GNU license as published by the Free Software Foundation, either version 3 of the License, or any later version. * This program is published without any warranty and not responsible for any errors or omissions, or for the results obtained from the use of this information. * All information is provided "as is", with no guarantee of completeness, accuracy, timeliness or of the results obtained from the use of this information, * and without warranty of any kind, express or implied. * * This document was last updated on July 15, 2021 * */ #ifndef MPU_9255_H_ #define MPU_9255_H_ #include "stm32f4xx_hal.h" #include <math.h> //Pow() and atan() #include <string.h> #define ADDRESS_9255 0x68 #define WHO_AM_I 0x75 #define POWER_1 0x6B #define POWER_2 0x6C #define CONFIG 0x1A #define GYRO_CONFIG 0x1B #define ACCEL_CONFIG 0x1C #define SMPLRT_DIV 0x19 #define INT_STATUS 0x3A #define ACCEL_XOUT_H 0x3B #define TEMP_OUT_H 0x41 #define GYRO_XOUT_H 0x43 #define i2c_timeout 100 typedef struct { int16_t Ax_RAW; int16_t Ay_RAW; int16_t Az_RAW; double Ax; double Ay; double Az; int16_t Gx_RAW; int16_t Gy_RAW; int16_t Gz_RAW; double Gx; double Gy; double Gz; double roll; double pitch; double Temp; // Temperature in C }MPU_DataStruct; HAL_StatusTypeDef MPU9255_Init(I2C_HandleTypeDef *hi2c_handle); // Initialize void MPU9255_Accel_Raw(MPU_DataStruct *rawAcc);// Raw Acceleration values void MPU9255_Accel_Scaled(MPU_DataStruct *scaledAcc); //Scaled Acceleration values void MPU9255_Gyro_Raw(MPU_DataStruct *rawGyro); // Raw Gyro values void MPU9255_Gyro_Scaled(MPU_DataStruct *scaledGyro); // Scaled void MPU9255_Angle(MPU_DataStruct *getAngle); void MPU_READ_ALL(MPU_DataStruct *ALL); // ALL VALUES #endif /* MPU_9255_H_ */

f0f87a553654e8dd118d1ce530596532ca79f599

06695d43ac30e328d372e62ad2e48566840688be

/include/fifo.h

92db65415859fa345701f67b00433a4397dab373

[]

no_license

duhuasong/myos

3d83faedc0b3b1ba81309e372e056af41e3dac25

6360fb1d771d5bafcd47c880128f39959aff22e2

refs/heads/master

2021-05-01T22:52:45.234000

2013-08-09T03:27:05

null

0

null

GB18030

C

false

387

h

fifo.h

#ifndef _CTYPE_H_ #define _CTYPE_H_ struct TASK; struct FIFO{ int *buf; int cur; int p; int free; int size; struct TASK* task;//我们让任务与fifo对应。 }; extern void fifo_init(struct FIFO * fifo, int * buf, int size,struct TASK* task); extern int fifo_put(struct FIFO*fifo, int data); extern int fifo_get(struct FIFO*fifo); extern int fifo_status(struct FIFO*fifo); #endif

0b1dcbf21b4cfb2f82bd6567f6158bccb9fcd4b0

4223eee4e127ac2d182baaa2bbfce5cfe7ada946

/src/syscall.h

fbd13a0e3c479e7b2e175ba6186daf0d75fbfbfa

[]

no_license

oaioa/advancedOperatingSystem

0930ca5cd248ae6ff8ca21d0d5d7b0694f953f80

45c275968709ab025a239f39eae05de87edaf9db

refs/heads/master

2020-04-09T02:41:38.512000

2018-12-01T14:14:33

159,950,306

0

null

UTF-8

C

false

128

h

syscall.h

#include <inttypes.h> void sys_reboot(); void sys_nop(); void sys_settime(uint64_t date_ms); void sys_yieldto(); int* sp_svc;

9b6962fbcc1fabcd0fbea42ea3a77ef1adf79a83

40b83dec47e6e24acf12f2c57fbd34a92205aa02

/cpu-cycles/libcpucycles/cpucycles/arm64-vct.c

a04b59e108edf6d1ba1e61cc82371f27b69be12a

[ "CC0-1.0", "Apache-2.0" ]

permissive

nymtech/nym

803133d223108773dfd65838707f00b23c83bdc2

a50b4ad211261a3d37a53eafd67770d57568dbeb

refs/heads/develop

2023-08-30T07:03:32.700000

2023-08-29T15:18:36

232,312,458

896

254

null

2023-09-14T15:54:13

2020-01-07T11:42:53

Rust

UTF-8

C

false

358

c

arm64-vct.c

// version 20230105 // public domain // djb // adapted from supercop/cpucycles/vct.c #include "cpucycles_internal.h" long long ticks(void) { long long result; asm volatile("mrs %0, CNTVCT_EL0" : "=r" (result)); return result; } long long ticks_setup(void) { if (!cpucycles_works(ticks)) return cpucycles_SKIP; return cpucycles_FINDMULTIPLIER; }

f1db4ad614a5ed627110551fa98f0ee0d95f2dbb

7e125605816ac46d01679b7f20f8c679322efe3e

/ext/toml/keytable.zep.c

fec1267549d06cfc8fd4808e2c716bcbce3e2ffe

[]

no_license

betrixed/toml-zephir

4689436d63c7e9854cb8445927d2e3127fb6af7d

ff33a41bc6ce64251585f70d4d8a48a6da8f3202

refs/heads/master

2021-05-01T21:57:08.153000

2018-02-23T01:57:31

120,981,528

1

0

null

UTF-8

C

false

true

11,353

c

keytable.zep.c

#ifdef HAVE_CONFIG_H #include "../ext_config.h" #endif #include <php.h> #include "../php_ext.h" #include "../ext.h" #include <Zend/zend_operators.h> #include <Zend/zend_exceptions.h> #include <Zend/zend_interfaces.h> #include "kernel/main.h" #include "kernel/object.h" #include "kernel/memory.h" #include "kernel/operators.h" #include "kernel/array.h" #include "kernel/fcall.h" /** * @author Michael Rynn */ /** * This is more general, no frills, object wrap of a PHP array * It is more inefficient than a bare PHP array. * The internal $_store is public for easy iteration. * Any PHP key type is allowed. * Strict TOML04 - says integer key values must * be converted to strings! * * Hence if we parsed an integer key, and converted it, and set the key as a string * and then extracted the key later, it would of integer type again, due to PHP's * convert everything that looks like an integer, to an integer, for Array keys. * "1" and intval(1) are the PHP same key, * stored as binary integer. Hash algorithms are faster on binary integers, because the Hash, * usually becomes a binary integer value, restricted to hash table storage. * Quite often integer values are what is intended. * It makes sense for internet HTML forms convenience, where everything is text, * and numeric values are returned as string. * If the numeric string is beyond an upper limit of representation it remains a string, * and in this case can never be an integer. * So if this class was used as TOML tables, all integer keys may need to be converted back to * string on retrieval. * This class gives a standard "referenced" array as object without a reference operator & */ ZEPHIR_INIT_CLASS(Toml_KeyTable) { ZEPHIR_REGISTER_CLASS(Toml, KeyTable, toml, keytable, toml_keytable_method_entry, ZEND_ACC_FINAL_CLASS); zend_declare_property_null(toml_keytable_ce, SL("_store"), ZEND_ACC_PUBLIC TSRMLS_CC); zend_declare_property_null(toml_keytable_ce, SL("_tag"), ZEND_ACC_PRIVATE TSRMLS_CC); zend_class_implements(toml_keytable_ce TSRMLS_CC, 1, toml_arrayable_ce); return SUCCESS; } PHP_METHOD(Toml_KeyTable, __construct) { zend_string *_5$$3, *_8$$5; zend_ulong _4$$3, _7$$5; zend_bool _0; zval *seed = NULL, seed_sub, __$null, _1, key$$3, value$$3, _2$$3, *_3$$3, key$$5, value$$5, *_6$$5, init$$7; zval *this_ptr = getThis(); ZVAL_UNDEF(&seed_sub); ZVAL_NULL(&__$null); ZVAL_UNDEF(&_1); ZVAL_UNDEF(&key$$3); ZVAL_UNDEF(&value$$3); ZVAL_UNDEF(&_2$$3); ZVAL_UNDEF(&key$$5); ZVAL_UNDEF(&value$$5); ZVAL_UNDEF(&init$$7); ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &seed); if (!seed) { seed = &seed_sub; seed = &__$null; } _0 = Z_TYPE_P(seed) == IS_OBJECT; if (_0) { _0 = (zephir_instance_of_ev(seed, toml_keytable_ce TSRMLS_CC)); } ZEPHIR_INIT_VAR(&_1); zephir_gettype(&_1, seed TSRMLS_CC); if (_0) { zephir_read_property(&_2$$3, seed, SL("_store"), PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_2$$3, 0, "toml/KeyTable.zep", 45); ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_2$$3), _4$$3, _5$$3, _3$$3) { ZEPHIR_INIT_NVAR(&key$$3); if (_5$$3 != NULL) { ZVAL_STR_COPY(&key$$3, _5$$3); } else { ZVAL_LONG(&key$$3, _4$$3); } ZEPHIR_INIT_NVAR(&value$$3); ZVAL_COPY(&value$$3, _3$$3); zephir_update_property_array(this_ptr, SL("_store"), &key$$3, &value$$3 TSRMLS_CC); } ZEND_HASH_FOREACH_END(); ZEPHIR_INIT_NVAR(&value$$3); ZEPHIR_INIT_NVAR(&key$$3); } else if (ZEPHIR_IS_STRING_IDENTICAL(&_1, "array")) { zephir_is_iterable(seed, 0, "toml/KeyTable.zep", 51); ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(seed), _7$$5, _8$$5, _6$$5) { ZEPHIR_INIT_NVAR(&key$$5); if (_8$$5 != NULL) { ZVAL_STR_COPY(&key$$5, _8$$5); } else { ZVAL_LONG(&key$$5, _7$$5); } ZEPHIR_INIT_NVAR(&value$$5); ZVAL_COPY(&value$$5, _6$$5); zephir_update_property_array(this_ptr, SL("_store"), &key$$5, &value$$5 TSRMLS_CC); } ZEND_HASH_FOREACH_END(); ZEPHIR_INIT_NVAR(&value$$5); ZEPHIR_INIT_NVAR(&key$$5); } else { ZEPHIR_INIT_VAR(&init$$7); array_init(&init$$7); zephir_update_property_zval(this_ptr, SL("_store"), &init$$7); } ZEPHIR_MM_RESTORE(); } PHP_METHOD(Toml_KeyTable, getTag) { zval *this_ptr = getThis(); RETURN_MEMBER(getThis(), "_tag"); } PHP_METHOD(Toml_KeyTable, setTag) { zval *tag, tag_sub; zval *this_ptr = getThis(); ZVAL_UNDEF(&tag_sub); zephir_fetch_params(0, 1, 0, &tag); zephir_update_property_zval(this_ptr, SL("_tag"), tag); } /** * @param type $index */ PHP_METHOD(Toml_KeyTable, offsetSet) { zval *index, index_sub, *value, value_sub; zval *this_ptr = getThis(); ZVAL_UNDEF(&index_sub); ZVAL_UNDEF(&value_sub); zephir_fetch_params(0, 2, 0, &index, &value); zephir_update_property_array(this_ptr, SL("_store"), index, value TSRMLS_CC); } PHP_METHOD(Toml_KeyTable, offsetExists) { zval *index, index_sub, _0; zval *this_ptr = getThis(); ZVAL_UNDEF(&index_sub); ZVAL_UNDEF(&_0); zephir_fetch_params(0, 1, 0, &index); zephir_read_property(&_0, this_ptr, SL("_store"), PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset(&_0, index)); } PHP_METHOD(Toml_KeyTable, offsetGet) { zval *index, index_sub, _0, _1; zval *this_ptr = getThis(); ZVAL_UNDEF(&index_sub); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); zephir_fetch_params(0, 1, 0, &index); zephir_read_property(&_0, this_ptr, SL("_store"), PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_1, &_0, index, PH_NOISY | PH_READONLY, "toml/KeyTable.zep", 80 TSRMLS_CC); RETURN_CTORW(&_1); } PHP_METHOD(Toml_KeyTable, offsetUnset) { zval *index, index_sub, _0; zval *this_ptr = getThis(); ZVAL_UNDEF(&index_sub); ZVAL_UNDEF(&_0); zephir_fetch_params(0, 1, 0, &index); zephir_read_property(&_0, this_ptr, SL("_store"), PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_0, index, PH_SEPARATE); } PHP_METHOD(Toml_KeyTable, count) { zval _0; zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); zephir_read_property(&_0, this_ptr, SL("_store"), PH_NOISY_CC | PH_READONLY); RETURN_LONG(zephir_fast_count_int(&_0 TSRMLS_CC)); } PHP_METHOD(Toml_KeyTable, get) { zval *index, index_sub, *defaultValue = NULL, defaultValue_sub, __$null, _0, _1, _2; zval *this_ptr = getThis(); ZVAL_UNDEF(&index_sub); ZVAL_UNDEF(&defaultValue_sub); ZVAL_NULL(&__$null); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &index, &defaultValue); if (!defaultValue) { defaultValue = &defaultValue_sub; defaultValue = &__$null; } ZEPHIR_INIT_VAR(&_0); zephir_read_property(&_1, this_ptr, SL("_store"), PH_NOISY_CC | PH_READONLY); if (zephir_array_isset(&_1, index)) { zephir_read_property(&_2, this_ptr, SL("_store"), PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_0, &_2, index, PH_NOISY, "toml/KeyTable.zep", 95 TSRMLS_CC); } else { ZEPHIR_CPY_WRT(&_0, defaultValue); } RETURN_CCTOR(&_0); } /** * Return array copy of everything with nested KeyTable object * mediation removed. * Modification to Config - allow recurse option, * false for no recurse. It can't be passed on. * @param bool $recurse * @return array */ PHP_METHOD(Toml_KeyTable, toArray) { zend_string *_4$$3; zend_ulong _3$$3; zend_long ZEPHIR_LAST_CALL_STATUS; zval *recurse_param = NULL, result, key, value, _0, _1$$3, *_2$$3, _7$$5; zend_bool recurse, _5$$4, _6$$4; zval *this_ptr = getThis(); ZVAL_UNDEF(&result); ZVAL_UNDEF(&key); ZVAL_UNDEF(&value); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1$$3); ZVAL_UNDEF(&_7$$5); ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &recurse_param); if (!recurse_param) { recurse = 1; } else { recurse = zephir_get_boolval(recurse_param); } ZEPHIR_INIT_VAR(&result); array_init(&result); zephir_read_property(&_0, this_ptr, SL("_store"), PH_NOISY_CC | PH_READONLY); if (!(ZEPHIR_IS_EMPTY(&_0))) { zephir_read_property(&_1$$3, this_ptr, SL("_store"), PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_1$$3, 0, "toml/KeyTable.zep", 118); ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_1$$3), _3$$3, _4$$3, _2$$3) { ZEPHIR_INIT_NVAR(&key); if (_4$$3 != NULL) { ZVAL_STR_COPY(&key, _4$$3); } else { ZVAL_LONG(&key, _3$$3); } ZEPHIR_INIT_NVAR(&value); ZVAL_COPY(&value, _2$$3); _5$$4 = recurse; if (_5$$4) { _5$$4 = Z_TYPE_P(&value) == IS_OBJECT; } _6$$4 = _5$$4; if (_6$$4) { _6$$4 = (zephir_instance_of_ev(&value, toml_arrayable_ce TSRMLS_CC)); } if (_6$$4) { ZEPHIR_CALL_METHOD(&_7$$5, &value, "toarray", NULL, 0); zephir_check_call_status(); zephir_array_update_zval(&result, &key, &_7$$5, PH_COPY | PH_SEPARATE); } else { zephir_array_update_zval(&result, &key, &value, PH_COPY | PH_SEPARATE); } } ZEND_HASH_FOREACH_END(); ZEPHIR_INIT_NVAR(&value); ZEPHIR_INIT_NVAR(&key); } RETURN_CCTOR(&result); } /** * @param myKeyTable should be a KeyTable * @return KeyTable */ PHP_METHOD(Toml_KeyTable, merge) { zend_long ZEPHIR_LAST_CALL_STATUS; zval *kt, kt_sub; zval *this_ptr = getThis(); ZVAL_UNDEF(&kt_sub); ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &kt); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_merge", NULL, 1, kt); zephir_check_call_status(); RETURN_MM(); } /** * Merge values in $config, into the properties of $instance * * @param \Yosy\KeyTable $config * @param \Yosy\KeyTable $instance * @return \Yosy\KeyTable */ PHP_METHOD(Toml_KeyTable, _merge) { zend_bool _5$$6, _6$$6; zend_string *_3; zend_ulong _2; zephir_fcall_cache_entry *_7 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; zval *kt, kt_sub, *target = NULL, target_sub, __$null, key, value, myObj, _0, *_1, _4$$4; zval *this_ptr = getThis(); ZVAL_UNDEF(&kt_sub); ZVAL_UNDEF(&target_sub); ZVAL_NULL(&__$null); ZVAL_UNDEF(&key); ZVAL_UNDEF(&value); ZVAL_UNDEF(&myObj); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_4$$4); ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &kt, &target); if (!target) { target = &target_sub; ZEPHIR_CPY_WRT(target, &__$null); } else { ZEPHIR_SEPARATE_PARAM(target); } if (!(Z_TYPE_P(target) == IS_OBJECT)) { ZEPHIR_CPY_WRT(target, this_ptr); } zephir_read_property(&_0, kt, SL("_store"), PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_0, 0, "toml/KeyTable.zep", 160); ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_0), _2, _3, _1) { ZEPHIR_INIT_NVAR(&key); if (_3 != NULL) { ZVAL_STR_COPY(&key, _3); } else { ZVAL_LONG(&key, _2); } ZEPHIR_INIT_NVAR(&value); ZVAL_COPY(&value, _1); ZEPHIR_OBS_NVAR(&myObj); zephir_read_property(&_4$$4, target, SL("_store"), PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&myObj, &_4$$4, &key, 0 TSRMLS_CC))) { ZEPHIR_INIT_NVAR(&myObj); ZVAL_NULL(&myObj); } if (Z_TYPE_P(&myObj) == IS_OBJECT) { _5$$6 = (zephir_is_instance_of(&myObj, SL("Yosy\\KeyTable") TSRMLS_CC)); if (_5$$6) { _5$$6 = Z_TYPE_P(&value) == IS_OBJECT; } _6$$6 = _5$$6; if (_6$$6) { _6$$6 = (zephir_instance_of_ev(&value, toml_keytable_ce TSRMLS_CC)); } if (_6$$6) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "_merge", &_7, 1, &value, &myObj); zephir_check_call_status(); continue; } } zephir_update_property_array(target, SL("_store"), &key, &value TSRMLS_CC); } ZEND_HASH_FOREACH_END(); ZEPHIR_INIT_NVAR(&value); ZEPHIR_INIT_NVAR(&key); RETVAL_ZVAL(target, 1, 0); RETURN_MM(); }

4cd08a2abcd527351a8c1982d7b0667bf39de073

933b3ba215f53617d722b479ca2fe972e7225610

/GUICode/Core/GUI2DLib.c

f9448ba6388973412adf50fc4ce90bd6b9acac9f

[]

no_license

symfund/eclipse_ucgui_3.98

92cc02be1930bd504e22e271366ae950f2f7024e

d49b0da1a044e4e997e6dede1df81fc821c6a0e4

refs/heads/master

2023-03-29T03:27:58.459000

2021-03-24T02:20:02

296,966,304

0

null

UTF-8

C

false

3,304

c

GUI2DLib.c

/* ********************************************************************************************************* * uC/GUI V3.98 * Universal graphic software for embedded applications * * (c) Copyright 2002, Micrium Inc., Weston, FL * (c) Copyright 2002, SEGGER Microcontroller Systeme GmbH * * �C/GUI is protected by international copyright laws. Knowledge of the * source code may not be used to write a similar product. This file may * only be used in accordance with a license and should not be redistributed * in any way. We appreciate your understanding and fairness. * ---------------------------------------------------------------------- File : GUI2DLib.C Purpose : Main part of the 2D graphics library ---------------------------END-OF-HEADER------------------------------ */ //#include <stddef.h> /* needed for definition of NULL */ #include "GUI_Protected.h" #include "GUIDebug.h" /********************************************************************* * * Public code * ********************************************************************** */ #define RETURN_IF_OUT() \ if (x0 > x1) return; \ if (y0 > y1) return; #define CLIP_X() \ if (x0 < GUI_Context.ClipRect.x0) { x0 = GUI_Context.ClipRect.x0; } \ if (x1 > GUI_Context.ClipRect.x1) { x1 = GUI_Context.ClipRect.x1; } #define CLIP_Y() \ if (y0 < GUI_Context.ClipRect.y0) { y0 = GUI_Context.ClipRect.y0; } \ if (y1 > GUI_Context.ClipRect.y1) { y1 = GUI_Context.ClipRect.y1; } /********************************************************************* * * GUI_MoveRel */ /*tbd: GL_LinePos. */ void GUI_MoveRel(I32 dx, I32 dy) { GUI_Context.DrawPosX += dx; GUI_Context.DrawPosY += dy; } /********************************************************************* * * GL_MoveTo */ void GL_MoveTo(I32 x, I32 y) { GUI_Context.DrawPosX = x; GUI_Context.DrawPosY = y; } /********************************************************************* * * GUI_MoveTo */ void GUI_MoveTo(I32 x, I32 y) { #if (GUI_WINSUPPORT) WM_ADDORG(x,y); #endif GL_MoveTo(x,y); } /********************************************************************* * * Rectangle filling / inverting * ********************************************************************** */ /********************************************************************* * * _DrawRect */ static void _DrawRect(I32 x0, I32 y0, I32 x1, I32 y1) { LCD_DrawHLine(x0, y0, x1); LCD_DrawHLine(x0, y1, x1); LCD_DrawVLine(x0, y0 + 1, y1 - 1); LCD_DrawVLine(x1, y0 + 1, y1 - 1); } /********************************************************************* * * GUI_DrawRect */ void GUI_DrawRect(I32 x0, I32 y0, I32 x1, I32 y1) { #if GUI_WINSUPPORT /* Perform clipping and check if there is something to do */ WM_ADDORG(x0, y0); WM_ADDORG(x1, y1); CLIP_X(); CLIP_Y(); RETURN_IF_OUT(); #endif _DrawRect(x0, y0, x1, y1); } /*************************** End of file ****************************/

06491a5a27a2ddef41c62fc33d0230cefb6016fc

7eaf54a78c9e2117247cb2ab6d3a0c20719ba700

/SOFTWARE/A64-TERES/linux-a64/drivers/ata/libata-acpi.c

cf4e7020adacde5e69881a21adb0c578d31d7a3e

[ "Linux-syscall-note", "GPL-2.0-only", "GPL-1.0-or-later", "LicenseRef-scancode-free-unknown", "Apache-2.0" ]

permissive

OLIMEX/DIY-LAPTOP

ae82f4ee79c641d9aee444db9a75f3f6709afa92

a3fafd1309135650bab27f5eafc0c32bc3ca74ee

refs/heads/rel3

2023-08-04T01:54:19.483000

2023-04-03T07:18:12

80,094,055

507

92

Apache-2.0

2023-04-03T07:05:59

2017-01-26T07:25:50

C

UTF-8

C

false

28,836

c

libata-acpi.c

/* * libata-acpi.c * Provides ACPI support for PATA/SATA. * * Copyright (C) 2006 Intel Corp. * Copyright (C) 2006 Randy Dunlap */ #include <linux/module.h> #include <linux/ata.h> #include <linux/delay.h> #include <linux/device.h> #include <linux/errno.h> #include <linux/kernel.h> #include <linux/acpi.h> #include <linux/libata.h> #include <linux/pci.h> #include <linux/slab.h> #include <linux/pm_runtime.h> #include <scsi/scsi_device.h> #include "libata.h" #include <acpi/acpi_bus.h> unsigned int ata_acpi_gtf_filter = ATA_ACPI_FILTER_DEFAULT; module_param_named(acpi_gtf_filter, ata_acpi_gtf_filter, int, 0644); MODULE_PARM_DESC(acpi_gtf_filter, "filter mask for ACPI _GTF commands, set to filter out (0x1=set xfermode, 0x2=lock/freeze lock, 0x4=DIPM, 0x8=FPDMA non-zero offset, 0x10=FPDMA DMA Setup FIS auto-activate)"); #define NO_PORT_MULT 0xffff #define SATA_ADR(root, pmp) (((root) << 16) | (pmp)) #define REGS_PER_GTF 7 struct ata_acpi_gtf { u8 tf[REGS_PER_GTF]; /* regs. 0x1f1 - 0x1f7 */ } __packed; /* * Helper - belongs in the PCI layer somewhere eventually */ static int is_pci_dev(struct device *dev) { return (dev->bus == &pci_bus_type); } static void ata_acpi_clear_gtf(struct ata_device *dev) { kfree(dev->gtf_cache); dev->gtf_cache = NULL; } /** * ata_ap_acpi_handle - provide the acpi_handle for an ata_port * @ap: the acpi_handle returned will correspond to this port * * Returns the acpi_handle for the ACPI namespace object corresponding to * the ata_port passed into the function, or NULL if no such object exists */ acpi_handle ata_ap_acpi_handle(struct ata_port *ap) { if (ap->flags & ATA_FLAG_ACPI_SATA) return NULL; return ap->scsi_host ? DEVICE_ACPI_HANDLE(&ap->scsi_host->shost_gendev) : NULL; } EXPORT_SYMBOL(ata_ap_acpi_handle); /** * ata_dev_acpi_handle - provide the acpi_handle for an ata_device * @dev: the acpi_device returned will correspond to this port * * Returns the acpi_handle for the ACPI namespace object corresponding to * the ata_device passed into the function, or NULL if no such object exists */ acpi_handle ata_dev_acpi_handle(struct ata_device *dev) { acpi_integer adr; struct ata_port *ap = dev->link->ap; if (libata_noacpi || dev->flags & ATA_DFLAG_ACPI_DISABLED) return NULL; if (ap->flags & ATA_FLAG_ACPI_SATA) { if (!sata_pmp_attached(ap)) adr = SATA_ADR(ap->port_no, NO_PORT_MULT); else adr = SATA_ADR(ap->port_no, dev->link->pmp); return acpi_get_child(DEVICE_ACPI_HANDLE(ap->host->dev), adr); } else return acpi_get_child(ata_ap_acpi_handle(ap), dev->devno); } EXPORT_SYMBOL(ata_dev_acpi_handle); /* @ap and @dev are the same as ata_acpi_handle_hotplug() */ static void ata_acpi_detach_device(struct ata_port *ap, struct ata_device *dev) { if (dev) dev->flags |= ATA_DFLAG_DETACH; else { struct ata_link *tlink; struct ata_device *tdev; ata_for_each_link(tlink, ap, EDGE) ata_for_each_dev(tdev, tlink, ALL) tdev->flags |= ATA_DFLAG_DETACH; } ata_port_schedule_eh(ap); } /** * ata_acpi_handle_hotplug - ACPI event handler backend * @ap: ATA port ACPI event occurred * @dev: ATA device ACPI event occurred (can be NULL) * @event: ACPI event which occurred * * All ACPI bay / device realted events end up in this function. If * the event is port-wide @dev is NULL. If the event is specific to a * device, @dev points to it. * * Hotplug (as opposed to unplug) notification is always handled as * port-wide while unplug only kills the target device on device-wide * event. * * LOCKING: * ACPI notify handler context. May sleep. */ static void ata_acpi_handle_hotplug(struct ata_port *ap, struct ata_device *dev, u32 event) { struct ata_eh_info *ehi = &ap->link.eh_info; int wait = 0; unsigned long flags; spin_lock_irqsave(ap->lock, flags); /* * When dock driver calls into the routine, it will always use * ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and * ACPI_NOTIFY_EJECT_REQUEST for remove */ switch (event) { case ACPI_NOTIFY_BUS_CHECK: case ACPI_NOTIFY_DEVICE_CHECK: ata_ehi_push_desc(ehi, "ACPI event"); ata_ehi_hotplugged(ehi); ata_port_freeze(ap); break; case ACPI_NOTIFY_EJECT_REQUEST: ata_ehi_push_desc(ehi, "ACPI event"); ata_acpi_detach_device(ap, dev); wait = 1; break; } spin_unlock_irqrestore(ap->lock, flags); if (wait) { ata_port_wait_eh(ap); flush_work(&ap->hotplug_task.work); } } static void ata_acpi_dev_notify_dock(acpi_handle handle, u32 event, void *data) { struct ata_device *dev = data; ata_acpi_handle_hotplug(dev->link->ap, dev, event); } static void ata_acpi_ap_notify_dock(acpi_handle handle, u32 event, void *data) { struct ata_port *ap = data; ata_acpi_handle_hotplug(ap, NULL, event); } static void ata_acpi_uevent(struct ata_port *ap, struct ata_device *dev, u32 event) { struct kobject *kobj = NULL; char event_string[20]; char *envp[] = { event_string, NULL }; if (dev) { if (dev->sdev) kobj = &dev->sdev->sdev_gendev.kobj; } else kobj = &ap->dev->kobj; if (kobj) { snprintf(event_string, 20, "BAY_EVENT=%d", event); kobject_uevent_env(kobj, KOBJ_CHANGE, envp); } } static void ata_acpi_ap_uevent(acpi_handle handle, u32 event, void *data) { ata_acpi_uevent(data, NULL, event); } static void ata_acpi_dev_uevent(acpi_handle handle, u32 event, void *data) { struct ata_device *dev = data; ata_acpi_uevent(dev->link->ap, dev, event); } static const struct acpi_dock_ops ata_acpi_dev_dock_ops = { .handler = ata_acpi_dev_notify_dock, .uevent = ata_acpi_dev_uevent, }; static const struct acpi_dock_ops ata_acpi_ap_dock_ops = { .handler = ata_acpi_ap_notify_dock, .uevent = ata_acpi_ap_uevent, }; void ata_acpi_hotplug_init(struct ata_host *host) { int i; for (i = 0; i < host->n_ports; i++) { struct ata_port *ap = host->ports[i]; acpi_handle handle; struct ata_device *dev; if (!ap) continue; handle = ata_ap_acpi_handle(ap); if (handle) { /* we might be on a docking station */ register_hotplug_dock_device(handle, &ata_acpi_ap_dock_ops, ap, NULL, NULL); } ata_for_each_dev(dev, &ap->link, ALL) { handle = ata_dev_acpi_handle(dev); if (!handle) continue; /* we might be on a docking station */ register_hotplug_dock_device(handle, &ata_acpi_dev_dock_ops, dev, NULL, NULL); } } } /** * ata_acpi_dissociate - dissociate ATA host from ACPI objects * @host: target ATA host * * This function is called during driver detach after the whole host * is shut down. * * LOCKING: * EH context. */ void ata_acpi_dissociate(struct ata_host *host) { int i; /* Restore initial _GTM values so that driver which attaches * afterward can use them too. */ for (i = 0; i < host->n_ports; i++) { struct ata_port *ap = host->ports[i]; const struct ata_acpi_gtm *gtm = ata_acpi_init_gtm(ap); if (ata_ap_acpi_handle(ap) && gtm) ata_acpi_stm(ap, gtm); } } static int __ata_acpi_gtm(struct ata_port *ap, acpi_handle handle, struct ata_acpi_gtm *gtm) { struct acpi_buffer output = { .length = ACPI_ALLOCATE_BUFFER }; union acpi_object *out_obj; acpi_status status; int rc = 0; status = acpi_evaluate_object(handle, "_GTM", NULL, &output); rc = -ENOENT; if (status == AE_NOT_FOUND) goto out_free; rc = -EINVAL; if (ACPI_FAILURE(status)) { ata_port_err(ap, "ACPI get timing mode failed (AE 0x%x)\n", status); goto out_free; } out_obj = output.pointer; if (out_obj->type != ACPI_TYPE_BUFFER) { ata_port_warn(ap, "_GTM returned unexpected object type 0x%x\n", out_obj->type); goto out_free; } if (out_obj->buffer.length != sizeof(struct ata_acpi_gtm)) { ata_port_err(ap, "_GTM returned invalid length %d\n", out_obj->buffer.length); goto out_free; } memcpy(gtm, out_obj->buffer.pointer, sizeof(struct ata_acpi_gtm)); rc = 0; out_free: kfree(output.pointer); return rc; } /** * ata_acpi_gtm - execute _GTM * @ap: target ATA port * @gtm: out parameter for _GTM result * * Evaluate _GTM and store the result in @gtm. * * LOCKING: * EH context. * * RETURNS: * 0 on success, -ENOENT if _GTM doesn't exist, -errno on failure. */ int ata_acpi_gtm(struct ata_port *ap, struct ata_acpi_gtm *gtm) { if (ata_ap_acpi_handle(ap)) return __ata_acpi_gtm(ap, ata_ap_acpi_handle(ap), gtm); else return -EINVAL; } EXPORT_SYMBOL_GPL(ata_acpi_gtm); /** * ata_acpi_stm - execute _STM * @ap: target ATA port * @stm: timing parameter to _STM * * Evaluate _STM with timing parameter @stm. * * LOCKING: * EH context. * * RETURNS: * 0 on success, -ENOENT if _STM doesn't exist, -errno on failure. */ int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm) { acpi_status status; struct ata_acpi_gtm stm_buf = *stm; struct acpi_object_list input; union acpi_object in_params[3]; in_params[0].type = ACPI_TYPE_BUFFER; in_params[0].buffer.length = sizeof(struct ata_acpi_gtm); in_params[0].buffer.pointer = (u8 *)&stm_buf; /* Buffers for id may need byteswapping ? */ in_params[1].type = ACPI_TYPE_BUFFER; in_params[1].buffer.length = 512; in_params[1].buffer.pointer = (u8 *)ap->link.device[0].id; in_params[2].type = ACPI_TYPE_BUFFER; in_params[2].buffer.length = 512; in_params[2].buffer.pointer = (u8 *)ap->link.device[1].id; input.count = 3; input.pointer = in_params; status = acpi_evaluate_object(ata_ap_acpi_handle(ap), "_STM", &input, NULL); if (status == AE_NOT_FOUND) return -ENOENT; if (ACPI_FAILURE(status)) { ata_port_err(ap, "ACPI set timing mode failed (status=0x%x)\n", status); return -EINVAL; } return 0; } EXPORT_SYMBOL_GPL(ata_acpi_stm); /** * ata_dev_get_GTF - get the drive bootup default taskfile settings * @dev: target ATA device * @gtf: output parameter for buffer containing _GTF taskfile arrays * * This applies to both PATA and SATA drives. * * The _GTF method has no input parameters. * It returns a variable number of register set values (registers * hex 1F1..1F7, taskfiles). * The <variable number> is not known in advance, so have ACPI-CA * allocate the buffer as needed and return it, then free it later. * * LOCKING: * EH context. * * RETURNS: * Number of taskfiles on success, 0 if _GTF doesn't exist. -EINVAL * if _GTF is invalid. */ static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf) { struct ata_port *ap = dev->link->ap; acpi_status status; struct acpi_buffer output; union acpi_object *out_obj; int rc = 0; /* if _GTF is cached, use the cached value */ if (dev->gtf_cache) { out_obj = dev->gtf_cache; goto done; } /* set up output buffer */ output.length = ACPI_ALLOCATE_BUFFER; output.pointer = NULL; /* ACPI-CA sets this; save/free it later */ if (ata_msg_probe(ap)) ata_dev_dbg(dev, "%s: ENTER: port#: %d\n", __func__, ap->port_no); /* _GTF has no input parameters */ status = acpi_evaluate_object(ata_dev_acpi_handle(dev), "_GTF", NULL, &output); out_obj = dev->gtf_cache = output.pointer; if (ACPI_FAILURE(status)) { if (status != AE_NOT_FOUND) { ata_dev_warn(dev, "_GTF evaluation failed (AE 0x%x)\n", status); rc = -EINVAL; } goto out_free; } if (!output.length || !output.pointer) { if (ata_msg_probe(ap)) ata_dev_dbg(dev, "%s: Run _GTF: length or ptr is NULL (0x%llx, 0x%p)\n", __func__, (unsigned long long)output.length, output.pointer); rc = -EINVAL; goto out_free; } if (out_obj->type != ACPI_TYPE_BUFFER) { ata_dev_warn(dev, "_GTF unexpected object type 0x%x\n", out_obj->type); rc = -EINVAL; goto out_free; } if (out_obj->buffer.length % REGS_PER_GTF) { ata_dev_warn(dev, "unexpected _GTF length (%d)\n", out_obj->buffer.length); rc = -EINVAL; goto out_free; } done: rc = out_obj->buffer.length / REGS_PER_GTF; if (gtf) { *gtf = (void *)out_obj->buffer.pointer; if (ata_msg_probe(ap)) ata_dev_dbg(dev, "%s: returning gtf=%p, gtf_count=%d\n", __func__, *gtf, rc); } return rc; out_free: ata_acpi_clear_gtf(dev); return rc; } /** * ata_acpi_gtm_xfermode - determine xfermode from GTM parameter * @dev: target device * @gtm: GTM parameter to use * * Determine xfermask for @dev from @gtm. * * LOCKING: * None. * * RETURNS: * Determined xfermask. */ unsigned long ata_acpi_gtm_xfermask(struct ata_device *dev, const struct ata_acpi_gtm *gtm) { unsigned long xfer_mask = 0; unsigned int type; int unit; u8 mode; /* we always use the 0 slot for crap hardware */ unit = dev->devno; if (!(gtm->flags & 0x10)) unit = 0; /* PIO */ mode = ata_timing_cycle2mode(ATA_SHIFT_PIO, gtm->drive[unit].pio); xfer_mask |= ata_xfer_mode2mask(mode); /* See if we have MWDMA or UDMA data. We don't bother with * MWDMA if UDMA is available as this means the BIOS set UDMA * and our error changedown if it works is UDMA to PIO anyway. */ if (!(gtm->flags & (1 << (2 * unit)))) type = ATA_SHIFT_MWDMA; else type = ATA_SHIFT_UDMA; mode = ata_timing_cycle2mode(type, gtm->drive[unit].dma); xfer_mask |= ata_xfer_mode2mask(mode); return xfer_mask; } EXPORT_SYMBOL_GPL(ata_acpi_gtm_xfermask); /** * ata_acpi_cbl_80wire - Check for 80 wire cable * @ap: Port to check * @gtm: GTM data to use * * Return 1 if the @gtm indicates the BIOS selected an 80wire mode. */ int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm) { struct ata_device *dev; ata_for_each_dev(dev, &ap->link, ENABLED) { unsigned long xfer_mask, udma_mask; xfer_mask = ata_acpi_gtm_xfermask(dev, gtm); ata_unpack_xfermask(xfer_mask, NULL, NULL, &udma_mask); if (udma_mask & ~ATA_UDMA_MASK_40C) return 1; } return 0; } EXPORT_SYMBOL_GPL(ata_acpi_cbl_80wire); static void ata_acpi_gtf_to_tf(struct ata_device *dev, const struct ata_acpi_gtf *gtf, struct ata_taskfile *tf) { ata_tf_init(dev, tf); tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; tf->protocol = ATA_PROT_NODATA; tf->feature = gtf->tf[0]; /* 0x1f1 */ tf->nsect = gtf->tf[1]; /* 0x1f2 */ tf->lbal = gtf->tf[2]; /* 0x1f3 */ tf->lbam = gtf->tf[3]; /* 0x1f4 */ tf->lbah = gtf->tf[4]; /* 0x1f5 */ tf->device = gtf->tf[5]; /* 0x1f6 */ tf->command = gtf->tf[6]; /* 0x1f7 */ } static int ata_acpi_filter_tf(struct ata_device *dev, const struct ata_taskfile *tf, const struct ata_taskfile *ptf) { if (dev->gtf_filter & ATA_ACPI_FILTER_SETXFER) { /* libata doesn't use ACPI to configure transfer mode. * It will only confuse device configuration. Skip. */ if (tf->command == ATA_CMD_SET_FEATURES && tf->feature == SETFEATURES_XFER) return 1; } if (dev->gtf_filter & ATA_ACPI_FILTER_LOCK) { /* BIOS writers, sorry but we don't wanna lock * features unless the user explicitly said so. */ /* DEVICE CONFIGURATION FREEZE LOCK */ if (tf->command == ATA_CMD_CONF_OVERLAY && tf->feature == ATA_DCO_FREEZE_LOCK) return 1; /* SECURITY FREEZE LOCK */ if (tf->command == ATA_CMD_SEC_FREEZE_LOCK) return 1; /* SET MAX LOCK and SET MAX FREEZE LOCK */ if ((!ptf || ptf->command != ATA_CMD_READ_NATIVE_MAX) && tf->command == ATA_CMD_SET_MAX && (tf->feature == ATA_SET_MAX_LOCK || tf->feature == ATA_SET_MAX_FREEZE_LOCK)) return 1; } if (tf->command == ATA_CMD_SET_FEATURES && tf->feature == SETFEATURES_SATA_ENABLE) { /* inhibit enabling DIPM */ if (dev->gtf_filter & ATA_ACPI_FILTER_DIPM && tf->nsect == SATA_DIPM) return 1; /* inhibit FPDMA non-zero offset */ if (dev->gtf_filter & ATA_ACPI_FILTER_FPDMA_OFFSET && (tf->nsect == SATA_FPDMA_OFFSET || tf->nsect == SATA_FPDMA_IN_ORDER)) return 1; /* inhibit FPDMA auto activation */ if (dev->gtf_filter & ATA_ACPI_FILTER_FPDMA_AA && tf->nsect == SATA_FPDMA_AA) return 1; } return 0; } /** * ata_acpi_run_tf - send taskfile registers to host controller * @dev: target ATA device * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7) * * Outputs ATA taskfile to standard ATA host controller. * Writes the control, feature, nsect, lbal, lbam, and lbah registers. * Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect, * hob_lbal, hob_lbam, and hob_lbah. * * This function waits for idle (!BUSY and !DRQ) after writing * registers. If the control register has a new value, this * function also waits for idle after writing control and before * writing the remaining registers. * * LOCKING: * EH context. * * RETURNS: * 1 if command is executed successfully. 0 if ignored, rejected or * filtered out, -errno on other errors. */ static int ata_acpi_run_tf(struct ata_device *dev, const struct ata_acpi_gtf *gtf, const struct ata_acpi_gtf *prev_gtf) { struct ata_taskfile *pptf = NULL; struct ata_taskfile tf, ptf, rtf; unsigned int err_mask; const char *level; const char *descr; char msg[60]; int rc; if ((gtf->tf[0] == 0) && (gtf->tf[1] == 0) && (gtf->tf[2] == 0) && (gtf->tf[3] == 0) && (gtf->tf[4] == 0) && (gtf->tf[5] == 0) && (gtf->tf[6] == 0)) return 0; ata_acpi_gtf_to_tf(dev, gtf, &tf); if (prev_gtf) { ata_acpi_gtf_to_tf(dev, prev_gtf, &ptf); pptf = &ptf; } if (!ata_acpi_filter_tf(dev, &tf, pptf)) { rtf = tf; err_mask = ata_exec_internal(dev, &rtf, NULL, DMA_NONE, NULL, 0, 0); switch (err_mask) { case 0: level = KERN_DEBUG; snprintf(msg, sizeof(msg), "succeeded"); rc = 1; break; case AC_ERR_DEV: level = KERN_INFO; snprintf(msg, sizeof(msg), "rejected by device (Stat=0x%02x Err=0x%02x)", rtf.command, rtf.feature); rc = 0; break; default: level = KERN_ERR; snprintf(msg, sizeof(msg), "failed (Emask=0x%x Stat=0x%02x Err=0x%02x)", err_mask, rtf.command, rtf.feature); rc = -EIO; break; } } else { level = KERN_INFO; snprintf(msg, sizeof(msg), "filtered out"); rc = 0; } descr = ata_get_cmd_descript(tf.command); ata_dev_printk(dev, level, "ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x (%s) %s\n", tf.command, tf.feature, tf.nsect, tf.lbal, tf.lbam, tf.lbah, tf.device, (descr ? descr : "unknown"), msg); return rc; } /** * ata_acpi_exec_tfs - get then write drive taskfile settings * @dev: target ATA device * @nr_executed: out parameter for the number of executed commands * * Evaluate _GTF and execute returned taskfiles. * * LOCKING: * EH context. * * RETURNS: * Number of executed taskfiles on success, 0 if _GTF doesn't exist. * -errno on other errors. */ static int ata_acpi_exec_tfs(struct ata_device *dev, int *nr_executed) { struct ata_acpi_gtf *gtf = NULL, *pgtf = NULL; int gtf_count, i, rc; /* get taskfiles */ rc = ata_dev_get_GTF(dev, &gtf); if (rc < 0) return rc; gtf_count = rc; /* execute them */ for (i = 0; i < gtf_count; i++, gtf++) { rc = ata_acpi_run_tf(dev, gtf, pgtf); if (rc < 0) break; if (rc) { (*nr_executed)++; pgtf = gtf; } } ata_acpi_clear_gtf(dev); if (rc < 0) return rc; return 0; } /** * ata_acpi_push_id - send Identify data to drive * @dev: target ATA device * * _SDD ACPI object: for SATA mode only * Must be after Identify (Packet) Device -- uses its data * ATM this function never returns a failure. It is an optional * method and if it fails for whatever reason, we should still * just keep going. * * LOCKING: * EH context. * * RETURNS: * 0 on success, -ENOENT if _SDD doesn't exist, -errno on failure. */ static int ata_acpi_push_id(struct ata_device *dev) { struct ata_port *ap = dev->link->ap; acpi_status status; struct acpi_object_list input; union acpi_object in_params[1]; if (ata_msg_probe(ap)) ata_dev_dbg(dev, "%s: ix = %d, port#: %d\n", __func__, dev->devno, ap->port_no); /* Give the drive Identify data to the drive via the _SDD method */ /* _SDD: set up input parameters */ input.count = 1; input.pointer = in_params; in_params[0].type = ACPI_TYPE_BUFFER; in_params[0].buffer.length = sizeof(dev->id[0]) * ATA_ID_WORDS; in_params[0].buffer.pointer = (u8 *)dev->id; /* Output buffer: _SDD has no output */ /* It's OK for _SDD to be missing too. */ swap_buf_le16(dev->id, ATA_ID_WORDS); status = acpi_evaluate_object(ata_dev_acpi_handle(dev), "_SDD", &input, NULL); swap_buf_le16(dev->id, ATA_ID_WORDS); if (status == AE_NOT_FOUND) return -ENOENT; if (ACPI_FAILURE(status)) { ata_dev_warn(dev, "ACPI _SDD failed (AE 0x%x)\n", status); return -EIO; } return 0; } /** * ata_acpi_on_suspend - ATA ACPI hook called on suspend * @ap: target ATA port * * This function is called when @ap is about to be suspended. All * devices are already put to sleep but the port_suspend() callback * hasn't been executed yet. Error return from this function aborts * suspend. * * LOCKING: * EH context. * * RETURNS: * 0 on success, -errno on failure. */ int ata_acpi_on_suspend(struct ata_port *ap) { /* nada */ return 0; } /** * ata_acpi_on_resume - ATA ACPI hook called on resume * @ap: target ATA port * * This function is called when @ap is resumed - right after port * itself is resumed but before any EH action is taken. * * LOCKING: * EH context. */ void ata_acpi_on_resume(struct ata_port *ap) { const struct ata_acpi_gtm *gtm = ata_acpi_init_gtm(ap); struct ata_device *dev; if (ata_ap_acpi_handle(ap) && gtm) { /* _GTM valid */ /* restore timing parameters */ ata_acpi_stm(ap, gtm); /* _GTF should immediately follow _STM so that it can * use values set by _STM. Cache _GTF result and * schedule _GTF. */ ata_for_each_dev(dev, &ap->link, ALL) { ata_acpi_clear_gtf(dev); if (ata_dev_enabled(dev) && ata_dev_get_GTF(dev, NULL) >= 0) dev->flags |= ATA_DFLAG_ACPI_PENDING; } } else { /* SATA _GTF needs to be evaulated after _SDD and * there's no reason to evaluate IDE _GTF early * without _STM. Clear cache and schedule _GTF. */ ata_for_each_dev(dev, &ap->link, ALL) { ata_acpi_clear_gtf(dev); if (ata_dev_enabled(dev)) dev->flags |= ATA_DFLAG_ACPI_PENDING; } } } static int ata_acpi_choose_suspend_state(struct ata_device *dev, bool runtime) { int d_max_in = ACPI_STATE_D3_COLD; if (!runtime) goto out; /* * For ATAPI, runtime D3 cold is only allowed * for ZPODD in zero power ready state */ if (dev->class == ATA_DEV_ATAPI && !(zpodd_dev_enabled(dev) && zpodd_zpready(dev))) d_max_in = ACPI_STATE_D3_HOT; out: return acpi_pm_device_sleep_state(&dev->sdev->sdev_gendev, NULL, d_max_in); } static void sata_acpi_set_state(struct ata_port *ap, pm_message_t state) { bool runtime = PMSG_IS_AUTO(state); struct ata_device *dev; acpi_handle handle; int acpi_state; ata_for_each_dev(dev, &ap->link, ENABLED) { handle = ata_dev_acpi_handle(dev); if (!handle) continue; if (!(state.event & PM_EVENT_RESUME)) { acpi_state = ata_acpi_choose_suspend_state(dev, runtime); if (acpi_state == ACPI_STATE_D0) continue; if (runtime && zpodd_dev_enabled(dev) && acpi_state == ACPI_STATE_D3_COLD) zpodd_enable_run_wake(dev); acpi_bus_set_power(handle, acpi_state); } else { if (runtime && zpodd_dev_enabled(dev)) zpodd_disable_run_wake(dev); acpi_bus_set_power(handle, ACPI_STATE_D0); } } } /* ACPI spec requires _PS0 when IDE power on and _PS3 when power off */ static void pata_acpi_set_state(struct ata_port *ap, pm_message_t state) { struct ata_device *dev; acpi_handle port_handle; port_handle = ata_ap_acpi_handle(ap); if (!port_handle) return; /* channel first and then drives for power on and vica versa for power off */ if (state.event & PM_EVENT_RESUME) acpi_bus_set_power(port_handle, ACPI_STATE_D0); ata_for_each_dev(dev, &ap->link, ENABLED) { acpi_handle dev_handle = ata_dev_acpi_handle(dev); if (!dev_handle) continue; acpi_bus_set_power(dev_handle, state.event & PM_EVENT_RESUME ? ACPI_STATE_D0 : ACPI_STATE_D3); } if (!(state.event & PM_EVENT_RESUME)) acpi_bus_set_power(port_handle, ACPI_STATE_D3); } /** * ata_acpi_set_state - set the port power state * @ap: target ATA port * @state: state, on/off * * This function sets a proper ACPI D state for the device on * system and runtime PM operations. */ void ata_acpi_set_state(struct ata_port *ap, pm_message_t state) { if (ap->flags & ATA_FLAG_ACPI_SATA) sata_acpi_set_state(ap, state); else pata_acpi_set_state(ap, state); } /** * ata_acpi_on_devcfg - ATA ACPI hook called on device donfiguration * @dev: target ATA device * * This function is called when @dev is about to be configured. * IDENTIFY data might have been modified after this hook is run. * * LOCKING: * EH context. * * RETURNS: * Positive number if IDENTIFY data needs to be refreshed, 0 if not, * -errno on failure. */ int ata_acpi_on_devcfg(struct ata_device *dev) { struct ata_port *ap = dev->link->ap; struct ata_eh_context *ehc = &ap->link.eh_context; int acpi_sata = ap->flags & ATA_FLAG_ACPI_SATA; int nr_executed = 0; int rc; if (!ata_dev_acpi_handle(dev)) return 0; /* do we need to do _GTF? */ if (!(dev->flags & ATA_DFLAG_ACPI_PENDING) && !(acpi_sata && (ehc->i.flags & ATA_EHI_DID_HARDRESET))) return 0; /* do _SDD if SATA */ if (acpi_sata) { rc = ata_acpi_push_id(dev); if (rc && rc != -ENOENT) goto acpi_err; } /* do _GTF */ rc = ata_acpi_exec_tfs(dev, &nr_executed); if (rc) goto acpi_err; dev->flags &= ~ATA_DFLAG_ACPI_PENDING; /* refresh IDENTIFY page if any _GTF command has been executed */ if (nr_executed) { rc = ata_dev_reread_id(dev, 0); if (rc < 0) { ata_dev_err(dev, "failed to IDENTIFY after ACPI commands\n"); return rc; } } return 0; acpi_err: /* ignore evaluation failure if we can continue safely */ if (rc == -EINVAL && !nr_executed && !(ap->pflags & ATA_PFLAG_FROZEN)) return 0; /* fail and let EH retry once more for unknown IO errors */ if (!(dev->flags & ATA_DFLAG_ACPI_FAILED)) { dev->flags |= ATA_DFLAG_ACPI_FAILED; return rc; } dev->flags |= ATA_DFLAG_ACPI_DISABLED; ata_dev_warn(dev, "ACPI: failed the second time, disabled\n"); /* We can safely continue if no _GTF command has been executed * and port is not frozen. */ if (!nr_executed && !(ap->pflags & ATA_PFLAG_FROZEN)) return 0; return rc; } /** * ata_acpi_on_disable - ATA ACPI hook called when a device is disabled * @dev: target ATA device * * This function is called when @dev is about to be disabled. * * LOCKING: * EH context. */ void ata_acpi_on_disable(struct ata_device *dev) { ata_acpi_clear_gtf(dev); } static int compat_pci_ata(struct ata_port *ap) { struct device *dev = ap->tdev.parent; struct pci_dev *pdev; if (!is_pci_dev(dev)) return 0; pdev = to_pci_dev(dev); if ((pdev->class >> 8) != PCI_CLASS_STORAGE_SATA && (pdev->class >> 8) != PCI_CLASS_STORAGE_IDE) return 0; return 1; } static int ata_acpi_bind_host(struct ata_port *ap, acpi_handle *handle) { if (libata_noacpi || ap->flags & ATA_FLAG_ACPI_SATA) return -ENODEV; *handle = acpi_get_child(DEVICE_ACPI_HANDLE(ap->tdev.parent), ap->port_no); if (!*handle) return -ENODEV; if (__ata_acpi_gtm(ap, *handle, &ap->__acpi_init_gtm) == 0) ap->pflags |= ATA_PFLAG_INIT_GTM_VALID; return 0; } static int ata_acpi_bind_device(struct ata_port *ap, struct scsi_device *sdev, acpi_handle *handle) { struct ata_device *ata_dev; if (ap->flags & ATA_FLAG_ACPI_SATA) { if (!sata_pmp_attached(ap)) ata_dev = &ap->link.device[sdev->id]; else ata_dev = &ap->pmp_link[sdev->channel].device[sdev->id]; } else { ata_dev = &ap->link.device[sdev->id]; } *handle = ata_dev_acpi_handle(ata_dev); if (!*handle) return -ENODEV; return 0; } static int is_ata_port(const struct device *dev) { return dev->type == &ata_port_type; } static struct ata_port *dev_to_ata_port(struct device *dev) { while (!is_ata_port(dev)) { if (!dev->parent) return NULL; dev = dev->parent; } return to_ata_port(dev); } static int ata_acpi_find_device(struct device *dev, acpi_handle *handle) { struct ata_port *ap = dev_to_ata_port(dev); if (!ap) return -ENODEV; if (!compat_pci_ata(ap)) return -ENODEV; if (scsi_is_host_device(dev)) return ata_acpi_bind_host(ap, handle); else if (scsi_is_sdev_device(dev)) { struct scsi_device *sdev = to_scsi_device(dev); return ata_acpi_bind_device(ap, sdev, handle); } else return -ENODEV; } static struct acpi_bus_type ata_acpi_bus = { .name = "ATA", .find_device = ata_acpi_find_device, }; int ata_acpi_register(void) { return scsi_register_acpi_bus_type(&ata_acpi_bus); } void ata_acpi_unregister(void) { scsi_unregister_acpi_bus_type(&ata_acpi_bus); }

3c777fe3796cacc5f6ffc85d327845e4996c3574

ef37f427ddd18b37bf1a882423ba6f81e879864f

/usb_core.c

eb089b73e7c22df0094faca7feec541b311fdbca

[ "MIT" ]

permissive

ahmedalkabir/bluepill-serial-monster

23ba538cfcce3810ec70c9f42df2508cb7ba0464

f7d85767b855b9efed46befa293c1ab5f6d2bb54

refs/heads/main

2023-08-28T21:58:39.353000

2021-09-28T11:07:30

null

0

null

UTF-8

C

false

12,693

c

usb_core.c

/* * MIT License * * Copyright (c) 2020 Kirill Kotyagin */ #include <stddef.h> #include <string.h> #include "status_led.h" #include "usb_core.h" #include "usb_std.h" #include "usb_cdc.h" #include "usb_descriptors.h" #include "usb_io.h" #include "usb_uid.h" #include "usb_panic.h" #include "usb.h" /* Device Level Events */ static struct { usb_device_state_t state; uint8_t address; uint8_t configuration; } usb_device; void usb_device_handle_reset() { usb_device.state = usb_device_state_reset; usb_device.address = 0; usb_device.configuration = 0; usb_cdc_reset(); usb_io_reset(); } void usb_device_handle_configured() { if (usb_device.state != usb_device_state_configured) { usb_cdc_enable(); } } void usb_device_handle_suspend() { if (usb_device.state == usb_device_state_configured) { usb_cdc_suspend(); } USB->DADDR = USB_DADDR_EF; usb_device.state = usb_device_state_reset; } void usb_device_handle_wakeup() { } void usb_device_handle_frame() { usb_cdc_frame(); } void usb_device_poll() { usb_cdc_poll(); } /* Device Descriptor Requests Handling */ usb_status_t usb_control_endpoint_process_get_descriptor(usb_setup_t *setup, void **payload, size_t *payload_size, usb_tx_complete_cb_t *tx_callback_ptr) { usb_descriptor_type_t descriptor_type = (setup->wValue >> 8); uint8_t descriptor_index = (setup->wValue & 0xff); switch (descriptor_type) { case usb_descriptor_type_device: *payload = (void*)&usb_device_descriptor; *payload_size = usb_device_descriptor.bLength; break; case usb_descriptor_type_configuration: *payload = (void*)&usb_configuration_descriptor; *payload_size = usb_configuration_descriptor.config.wTotalLength; break; case usb_descriptor_type_string: if (descriptor_index == usb_string_index_serial) { usb_string_descriptor_t *uid_descriptor = usb_get_uid_string_descriptor(); *payload = uid_descriptor; *payload_size = uid_descriptor->bLength; } else { if (descriptor_index < usb_string_index_last) { *payload = (void*)usb_string_descriptors[descriptor_index]; *payload_size = usb_string_descriptors[descriptor_index]->bLength; } else { return usb_status_fail; } } break; default: return usb_status_fail; } return usb_status_ack; } /* Standard Control Endpoint Requests Handling */ static void usb_assign_device_address_cb() { USB->DADDR = USB_DADDR_EF | usb_device.address; usb_device.state = usb_device_state_address_set; } usb_status_t usb_control_endpoint_process_device_request(usb_setup_t *setup, void **payload, size_t *payload_size, usb_tx_complete_cb_t *tx_callback_ptr) { switch(setup->bRequest) { case usb_device_request_get_configuration: *(uint8_t*)payload[0] = usb_device.configuration; return usb_status_ack; case usb_device_request_get_descriptor: return usb_control_endpoint_process_get_descriptor(setup, payload, payload_size, tx_callback_ptr); case usb_device_request_get_status: ((uint8_t*)(*payload))[0] = 0; ((uint8_t*)(*payload))[1] = 0; return usb_status_ack; case usb_device_request_set_address: usb_device.address = setup->wValue & USB_DADDR_ADD_Msk; *tx_callback_ptr = usb_assign_device_address_cb; return usb_status_ack; case usb_device_request_set_configuration: { uint8_t device_configuration = setup->wValue & 0xff; if (device_configuration == 1) { usb_device.configuration = device_configuration; usb_device_handle_configured(); return usb_status_ack; } break; } case usb_device_request_set_descriptor: case usb_device_request_set_feature: case usb_device_request_clear_feature: break; default: break; } return usb_status_fail; } usb_status_t usb_control_endpoint_process_interface_request(usb_setup_t *setup, void **payload, size_t *payload_size, usb_tx_complete_cb_t *tx_callback_ptr) { if (setup->bRequest == usb_device_request_get_status) { ((uint8_t*)(*payload))[0] = 0; ((uint8_t*)(*payload))[1] = 0; return usb_status_ack; } return usb_status_fail; } usb_status_t usb_control_endpoint_process_endpoint_request(usb_setup_t *setup, void **payload, size_t *payload_size, usb_tx_complete_cb_t *tx_callback_ptr) { uint8_t ep_num = setup->wIndex & ~(usb_endpoint_direction_in); usb_endpoint_direction_t ep_direction = setup->wIndex & usb_endpoint_direction_in; if ((setup->bRequest == usb_device_request_set_feature) || (setup->bRequest == usb_device_request_clear_feature)) { uint8_t ep_stall = (setup->bRequest == usb_device_request_set_feature); usb_endpoint_set_stall(ep_num, ep_direction, ep_stall); return usb_status_ack; } else if (setup->bRequest == usb_device_request_get_status) { ((uint8_t*)(*payload))[0] = usb_endpoint_is_stalled(ep_num , ep_direction); ((uint8_t*)(*payload))[1] = 0; return usb_status_ack; } else { return usb_status_fail; } } /* Control Endpoint Request Processing */ usb_status_t usb_control_endpoint_process_request(usb_setup_t *setup, void **payload, size_t *payload_size, usb_tx_complete_cb_t *tx_callback_ptr) { usb_status_t status = usb_cdc_ctrl_process_request(setup, payload, payload_size, tx_callback_ptr); if (status != usb_status_fail) { return status; } if (setup->type == usb_setup_type_standard) { switch (setup->recepient) { case usb_setup_recepient_device: return usb_control_endpoint_process_device_request(setup, payload, payload_size, tx_callback_ptr); case usb_setup_recepient_interface: return usb_control_endpoint_process_interface_request(setup, payload, payload_size, tx_callback_ptr); case usb_setup_recepient_endpoint: return usb_control_endpoint_process_endpoint_request(setup, payload, payload_size, tx_callback_ptr); default: break; } } return usb_status_fail; } /* Control Endpoint Data Echange */ static struct { enum { usb_control_state_idle, usb_control_state_rx, usb_control_state_tx, usb_control_state_tx_zlp, usb_control_state_tx_last, usb_control_state_status_in, usb_control_state_status_out, } state; uint8_t setup_buf[USB_SETUP_MAX_SIZE]; void *payload; size_t payload_size; usb_setup_t *setup; usb_tx_complete_cb_t tx_complete_callback; } usb_control_ep_struct; void usb_control_endpoint_stall(uint8_t ep_num) { usb_endpoint_set_stall(ep_num, usb_endpoint_direction_out, 1); usb_endpoint_set_stall(ep_num, usb_endpoint_direction_in, 1); usb_control_ep_struct.state = usb_control_state_idle; } static void usb_control_endpoint_process_callback() { if (usb_control_ep_struct.tx_complete_callback) { usb_control_ep_struct.tx_complete_callback(); usb_control_ep_struct.tx_complete_callback = 0; } } static void usb_control_endpoint_process_tx(uint8_t ep_num) { size_t bytes_sent = 0; switch (usb_control_ep_struct.state) { case usb_control_state_tx: case usb_control_state_tx_zlp: bytes_sent = usb_send(ep_num, usb_control_ep_struct.payload, usb_control_ep_struct.payload_size); usb_control_ep_struct.payload = ((uint8_t*)usb_control_ep_struct.payload) + bytes_sent; usb_control_ep_struct.payload_size -= bytes_sent; if (usb_control_ep_struct.payload_size == 0) { if ((usb_control_ep_struct.state == usb_control_state_tx) || (bytes_sent != usb_endpoints[ep_num].tx_size)) { usb_control_ep_struct.state = usb_control_state_tx_last; } } break; case usb_control_state_tx_last: usb_control_ep_struct.state = usb_control_state_status_out; break; case usb_control_state_status_in: usb_control_ep_struct.state = usb_control_state_idle; usb_control_endpoint_process_callback(); break; default: usb_panic(); break; } } static void usb_control_endpoint_process_rx(uint8_t ep_num) { size_t setup_size; size_t payload_bytes_received = 0; switch (usb_control_ep_struct.state) { case usb_control_state_idle: setup_size = usb_read(ep_num, usb_control_ep_struct.setup_buf, sizeof(usb_setup_t)); if (setup_size != sizeof(usb_setup_t)) { usb_control_endpoint_stall(ep_num); return; } else { usb_control_ep_struct.setup = (usb_setup_t *)&usb_control_ep_struct.setup_buf; usb_control_ep_struct.payload = usb_control_ep_struct.setup->payload; usb_control_ep_struct.payload_size = usb_control_ep_struct.setup->wLength; if ((usb_control_ep_struct.setup->direction == usb_setup_direction_host_to_device) && (usb_control_ep_struct.setup->wLength != 0)) { if (usb_control_ep_struct.payload_size > USB_SETUP_MAX_PAYLOAD_SIZE) { usb_control_endpoint_stall(ep_num); } else { usb_control_ep_struct.state = usb_control_state_rx; } return; } } break; case usb_control_state_rx: payload_bytes_received = usb_read(ep_num, usb_control_ep_struct.payload, usb_control_ep_struct.payload_size); if (usb_control_ep_struct.payload_size != payload_bytes_received) { usb_control_ep_struct.payload = ((uint8_t*)usb_control_ep_struct.payload) + payload_bytes_received; usb_control_ep_struct.payload_size -= payload_bytes_received; return; } break; case usb_control_state_status_out: usb_read(ep_num, 0, 0); usb_control_ep_struct.state = usb_control_state_idle; usb_control_endpoint_process_callback(); return; default: usb_control_endpoint_stall(ep_num); return; } usb_control_ep_struct.payload = usb_control_ep_struct.setup->payload; usb_control_ep_struct.payload_size = USB_SETUP_MAX_PAYLOAD_SIZE; switch (usb_control_endpoint_process_request(usb_control_ep_struct.setup, &usb_control_ep_struct.payload, &usb_control_ep_struct.payload_size, &usb_control_ep_struct.tx_complete_callback)) { case usb_status_ack: if (usb_control_ep_struct.setup->direction == usb_setup_direction_device_to_host) { if (usb_control_ep_struct.payload_size < usb_control_ep_struct.setup->wLength) { usb_control_ep_struct.state = usb_control_state_tx_zlp; } else { if (usb_control_ep_struct.payload_size > usb_control_ep_struct.setup->wLength) { usb_control_ep_struct.payload_size = usb_control_ep_struct.setup->wLength; } usb_control_ep_struct.state = usb_control_state_tx; } usb_control_endpoint_process_tx(ep_num); return; } else { usb_send(ep_num, 0, 0); usb_control_ep_struct.state = usb_control_state_status_in; } break; case usb_status_nak: usb_control_ep_struct.state = usb_control_state_status_in; break; default: usb_control_endpoint_stall(ep_num); } } void usb_control_endpoint_event_handler(uint8_t ep_num, usb_endpoint_event_t ep_event) { if (ep_num == usb_endpoint_address_control) { if (ep_event == usb_endpoint_event_setup || ep_event == usb_endpoint_event_data_received) { if (ep_event == usb_endpoint_event_setup) { usb_control_ep_struct.state = usb_control_state_idle; } usb_control_endpoint_process_rx(ep_num); } else if (ep_event == usb_endpoint_event_data_sent) { usb_control_endpoint_process_tx(ep_num); } else { usb_panic(); } } else { usb_panic(); } } void usb_init() { usb_io_init(); }

c27f899bdced95e8dd1aafcf3119ae5cb604039b

2a34b0c2779c8220272cd3781a39c5867146b615

/src/libc/uv/uv_mutex_init_recursive.c

3714d711d8379209be160bb6458bcf6ab1a16288

[ "LicenseRef-scancode-unknown-license-reference", "BSD-2-Clause" ]

permissive

yurydelendik/cloudlibc

f824043879ee7147049eb2bf5b243e7b0b5ac530

b25d9232b3e5b3757231afdc888d2b9072673917

refs/heads/master

2020-04-10T02:42:27.618000

2018-12-15T00:53:03

160,750,519

0

NOASSERTION

2018-12-07T00:43:43

null

UTF-8

C

false

538

c

uv_mutex_init_recursive.c

// Copyright (c) 2017 Nuxi, https://nuxi.nl/ // // SPDX-License-Identifier: BSD-2-Clause #include <pthread.h> #include <uv.h> int uv_mutex_init_recursive(uv_mutex_t *handle) { pthread_mutexattr_t attr; int error = pthread_mutexattr_init(&attr); if (error != 0) return -error; error = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); if (error != 0) { pthread_mutexattr_destroy(&attr); return -error; } error = pthread_mutex_init(handle, &attr); pthread_mutexattr_destroy(&attr); return -error; }

0213c7e4791f16d922488d7e3a2994da2fedc128

51635684d03e47ebad12b8872ff469b83f36aa52

/external/gcc-12.1.0/gcc/testsuite/g++.dg/overload/ref-conv1.C

1c525fbc7822bcf86df68fc93cb3516ceffc9e56

[ "LGPL-2.1-only", "FSFAP", "LGPL-3.0-only", "GPL-3.0-only", "GPL-2.0-only", "GCC-exception-3.1", "LGPL-2.0-or-later", "Zlib", "LicenseRef-scancode-public-domain" ]

permissive

zhmu/ananas

8fb48ddfe3582f85ff39184fc7a3c58725fe731a

30850c1639f03bccbfb2f2b03361792cc8fae52e

refs/heads/master

2022-06-25T10:44:46.256000

2022-06-12T17:04:40

30,108,381

59

8

Zlib

2021-09-26T17:30:30

2015-01-31T09:44:33

C

UTF-8

C

false

242

c

ref-conv1.C

// PR c++/50442 // { dg-additional-options "-Wno-return-type" } template <typename T> struct MoveRef { operator T& () {} }; template <typename T> MoveRef <T> Move(T&) {} struct Thing {}; Thing foo(const Thing* p) { return Thing(Move(*p)); }

4532eced121b288fdffbbf947f47f2dcd8027840

987c34058d582d9f64eb4386e1eaca515d31ec82

/0x03-more_functions_nested_loops/10-print_triangle.c

24a430cbd53e69e69e38e3de7f6998fd926f702c

[]

no_license

GucciGerm/holbertonschool-low_level_programming

44f0c7ba22752e7a097bf338c6899d260fdce09c

e69b3a515443816b0c77dfc608e8afab46103787

refs/heads/master

2021-03-19T16:20:52.638000

2018-08-10T17:10:23

117,909,465

0

null

UTF-8

C

false

446

c

10-print_triangle.c

#include "holberton.h" /** * print_triangle - Function prints a triangle followed by a new line * @size: Represents the size of the triangle * */ void print_triangle(int size) { int a; int b; if (size > 0) { for (a = 1; a <= size; a++) { for (b = 0; b < size; b++) { if (b < size - a) { _putchar(' '); } else { _putchar('#'); } } _putchar('\n'); } } else { _putchar('\n'); } }

47e39a23e4995b46b01d8fb6514edef3b3ea965b

d6e1d668d99a482922081c7f36002fbc538a7729

/A3Q1/syntax.h

e44965e613c737d6e1e36faeccba133440678686

[]

no_license

afuadhossain/Intro_Modular_Programming

e47ce1349acb14edcb80c1d17f5f2430f6e68332

8c7ba0d311ec2574d6c7f1cb91006cc6f9b0a7ff

refs/heads/master

2021-05-05T01:52:08.822000

2016-04-30T22:36:57

119,763,491

0

null

UTF-8

C

false

156

h

syntax.h

//these are all the functions from syntax.c that can be utilzed by other c files int isValidCommand(char *token); int isValidExpression(char *expression);

5636859c81b44071565bfb4127f30035017be3e6

405d5d6c4b0e89562d67d354689c20cfe0d10d9e

/WinRTInteropTools/streamHelpers.h

9855bb5ad7a1ed41f5aa87549694a10ba5e987a8

[ "MIT" ]

permissive

asdlei99/WinRTInteropTools

7f8c7c86dcf6f29de57ca10b7bcd70882d26b3a6

0db9d30abb39669421977dbefbf8a684914d2f85

refs/heads/master

2023-07-13T23:35:03.211000

2021-08-23T07:17:45

null

0

null

UTF-8

C

false

417

h

streamHelpers.h

#pragma once #include <shcore.h> #include <windows.storage.streams.h> inline auto CreateStreamOverRandomAccessStream( winrt::Windows::Storage::Streams::IRandomAccessStream const& stream) { winrt::com_ptr<IStream> result; auto unknown = stream.as<IUnknown>(); winrt::check_hresult(::CreateStreamOverRandomAccessStream(unknown.get(), winrt::guid_of<IStream>(), result.put_void())); return result; }

ccee1842691901d4fd2186107bb603dc7e78df95

0598f42d187f67094f97a3dab94728ec2f088208

/C/Testh/newton.h

3b7a95a5f3b74b57070e972bae1b061aa69681d6

[]

no_license

TanXze/HaiZei

4ff8f7d667728644e53518c76344d48aecba3521

848a8d42e721d5166827acbdaec309d98b59f7f0

refs/heads/master

2020-03-28T18:20:19.267000

2019-01-21T11:36:02

148,872,749

0

null

UTF-8

C

false

349

h

newton.h

/************************************************************************* > File Name: newton.h > Author: Tanxiaoze > Mail: [email protected] > Created Time: 2018年10月07日星期日 19时48分52秒 ************************************************************************/ #ifndef _NEWTON_H #define _NEWTON_H double newton(double); #endif

c1fa477c4e670ba96cf53290fe01ac06c9eb4663

06cc925a6a1aa30ab239b398705d23895aac9bd4

/GPIO_driver/GPIO_interface.h

2bb5c8fcf361e38a6c56ec1cef8c6b41e36d9a06

[]

no_license

shaimaa-77/STM32_drivers

9d34096fa91729d991e74074c733e3883be9a793

55eb7840de6a9b5c3aa69f26b73d91f3d76a63d2

refs/heads/main

2023-08-30T21:40:18.895000

2021-10-02T15:51:45

310,468,421

0

null

UTF-8

C

false

2,844

h

GPIO_interface.h

/****************************************************************************************/ /* Author : Shaimaa Mahmoud */ /* Date : 18/8/2020 */ /* version : v01 */ /****************************************************************************************/ #ifndef GPIO_INTERFACE_H #define GPIO_INTERFACE_H #define GPIO_HIEGH 1 #define GPIO_LOW 0 #define GPIOA 0 #define GPIOB 1 #define GPIOC 2 /*DEFINITIONS FOR PINS*/ #define PIN0 0 #define PIN1 1 #define PIN2 2 #define PIN3 3 #define PIN4 4 #define PIN5 5 #define PIN6 6 #define PIN7 7 #define PIN8 8 #define PIN9 9 #define PIN10 10 #define PIN11 11 #define PIN12 12 #define PIN13 13 #define PIN14 14 #define PIN15 15 /* modes of GPIO */ //IN INPUT MODE 00 #define INPUT_ANALOG 0b0000 #define INPUT_FLOATING 0b0100 //sensitive for hiegh &low #define INPUT_PULL_UP_DOWN 0b1000 //it need anther config to be up or dwon // IN OUTPUT MODE #define OUTPUT_10MHZ_PUSH_PULL 0b0001 #define OUTPUT_10MHZ_OPEN_DRAIN 0b0101 #define OUTPUT_10MHZ_AF_PUSH_PULL 0b1001 #define INPUT_10MHZ_AF_PUSH_PULL 0b1101 #define OUTPUT_2MHZ_PUSH_PULL 0b0010 #define OUTPUT_2MHZ_OPEN_DRAIN 0b0110 #define OUTPUT_2MHZ_AF_PUSH_PULL 0b1010 #define INPUT_2MHZ_AF_PUSH_PULL 0b1110 #define OUTPUT_50MHZ_PUSH_PULL 0b0011 #define OUTPUT_50MHZ_OPEN_DRAIN 0b0111 #define OUTPUT_50MHZ_AF_PUSH_PULL 0b1011 #define INPUT_50MHZ_AF_PUSH_PULL 0b1111 /*PROTOTYPES FOR FUN USED*/ //FUN FOR SET DIRECTION OF THE PIN void GPIO_voidSetPinDirection(u8 copy_u8PORT , u8 copy_u8PIN , u8 copy_u8Mode ); //FUN FOR SET VALUE OF THE PIIN void GPIO_voidSetPinValue (u8 copy_u8PORT , u8 copy_u8PIN , u8 copy_u8Value); // FUN FOR GET VALUE OF THE PIN u8 GPIO_u8GetPinValue(u8 copy_u8PORT , u8 copy_u8PIN ); #endif

41017852ae7e7036cd36e2592fe2121e391d068a

fb3561e80f6d7d38458c58e5e0d208422a3a787f

/src/chainparamsseeds.h

5fe267aff24204924da2eb81376f9d4d40fc32f9

[ "MIT" ]

permissive

cryptoghass/sifcash

f375a0fab2323c15be6ee27c5614d5d1cc6d0e87

775954d5a61b9c876ca6c0ad90ad922a9e41250f

refs/heads/master

2020-03-30T08:12:08.827000

2018-08-22T15:07:48

null

0

null

UTF-8

C

false

1,450

h

chainparamsseeds.h

#ifndef BITCOIN_CHAINPARAMSSEEDS_H #define BITCOIN_CHAINPARAMSSEEDS_H /** * List of fixed seed nodes for the bitcoin network * AUTOGENERATED by contrib/seeds/generate-seeds.py * * Each line contains a 16-byte IPv6 address and a port. * IPv4 as well as onion addresses are wrapped inside a IPv6 address accordingly. */ // ***TODO*** fix generate-seeds.py and REGENERATE static SeedSpec6 pnSeed6_main[] = { {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xad,0x00,0x9d,0xeb}, 14033}, {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0x2a,0x3e,0x1b}, 14033}, {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x17,0x6c,0xd9,0x50}, 14033}, {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x67,0x17,0xd0,0xad}, 14033}, {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0x2a,0x3e,0x1c}, 14033} }; static SeedSpec6 pnSeed6_test[] = { {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xad,0x00,0x9d,0xeb}, 24033}, {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0x2a,0x3e,0x1b}, 24033}, {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x17,0x6c,0xd9,0x50}, 24033}, {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x67,0x17,0xd0,0xad}, 24033}, {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0x2a,0x3e,0x1c}, 24033} }; #endif // BITCOIN_CHAINPARAMSSEEDS_H

426cc8680f715e069070b70e402f6ba53edb2594

280f5ac90d60c77f3f24b6c8803893e860d73937

/lab 5/dzialka.c

4e533b80f913598b4837393174336b70540bbfff

[]

no_license

mpyrek/PI

fe0dfb8d0b054663e5d14ca45d7617c4ad4931a6

8a12d6952f483d0454b186a07a45333322c0ff33

refs/heads/main

2023-08-02T08:05:16.859000

2021-09-24T18:41:34

409,977,289

0

null

UTF-8

C

false

1,929

c

dzialka.c

#include <stdio.h> #include <stdlib.h> int licz(int **T,int **S,int **G,int n){ for(int i=0;i<n;i++){ if(T[0][i]==0){ G[0][i]=1; } else{ G[0][i]=0; } } for(int i=1;i<n;i++){ for(int j=0;j<n;j++){ if(T[i][j]==0){ G[i][j]=1+G[i-1][j]; } else{ G[i][j]=0; } } } for(int i=0;i<n;i++){ for(int j=0;j<n;j++){ int k=j-1; S[i][j]=G[i][j]; int minimum=G[i][j]; int z=0; while(k>=0){ if(minimum<=G[i][k]){ z=minimum*(j-k+1); } else{ minimum=G[i][k]; z=minimum*(j-k+1); } if(S[i][j]<z){ S[i][j]=z; } k--; } } } int z=0; for(int i=0;i<n;i++){ for(int j=0;j<n;j++){ if(z<S[i][j]){ z=S[i][j]; } } } printf("%d", z); } int main() { int n=0; scanf("%d",&n); int **T; T=(int**)malloc(n*sizeof(int*)); for(int i=0;i<n;i++){ T[i]=(int*)malloc(n*sizeof(int)); } for(int i=0;i<n;i++){ for(int j=0;j<n;j++){ scanf("%d",&T[i][j]); } } int **G; G=(int**)malloc(n*sizeof(int*)); for(int i=0;i<n;i++){ G[i]=(int*)malloc(n*sizeof(int)); } int **S; S=(int**)malloc(n*sizeof(int*)); for(int i=0;i<n;i++){ S[i]=(int*)malloc(n*sizeof(int)); } licz(T,S,G,n); for(int i=0;i<n;i++){ free(T[i]); free(S[i]); free(G[i]); } free(S); free(T); free(G); }

1ed8bf13bac870fdc95f9cde3387ccb97449a25c

4945846704933d53a67178523c691cc9b1ca63c2

/libft/ft_strclr.c

43adfea9344b5ccb12c34eaea05c5d6f7e09c370

[]

no_license

mpotapov/fractol

676339cfa3910f45271e58f7221b3ac1935f10bd

e2a885877395a97cd890eabc5b2af7c18d525cd3

refs/heads/master

2021-09-16T22:32:43.540000

2018-05-30T14:51:38

107,035,047

0

null

UTF-8

C

false

982

c

ft_strclr.c

/* ************************************************************************** */ /* */ /* ::: :::::::: */ /* ft_strclr.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: mpotapov <[email protected]> +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/12/29 17:55:48 by mpotapov #+# #+# */ /* Updated: 2016/12/30 17:49:21 by mpotapov ### ########.fr */ /* */ /* ************************************************************************** */ #include "libft.h" void ft_strclr(char *s) { if (s != NULL) while (*s) *s++ = 0; }

55bfb81efa1999fc0c7a138fb47a0f3b36edb739

afafb6a0608c658b5b0b0e96f071c8539f0aee60

/mydll/MyLib.h

033bf8fc8d87c9a3844a621e0da486b5a47ad646

[]

no_license

OlehKostiv/mydll

7d69f9c7e6ba995665117703b20727951b30ecdc

45f501649e6a565b3c1f8dbc83ad0d6c46a8eeed

refs/heads/master

2021-09-07T16:56:16.194000

2018-02-26T12:07:33

122,381,365

0

null

UTF-8

C

false

150

h

MyLib.h

#pragma once #ifndef MYLIBAPI #define MYLIBAPI extern "C" __declspec(dllimport) #endif MYLIBAPI int g_result; MYLIBAPI int Add(int nLeft, int nRight);

9e74c9a92457d019b135360e21725fc80ec7070e

f82e4c16ed3dbb95b6753e25b477cb9f9c1d379d

/Bai3_1.c

708e86b8000ad3b04b2e453440d9a3f677d6c5a1

[]

no_license

sandl99/THDC

78cb0f37e5f1d7600e891e7a02f523f2a4626ce6

dcf8110fefe17bad1784c742fff8580c91f9b37b

refs/heads/master

2021-10-09T04:37:00.145000

2018-12-21T07:54:56

null

0

null

UTF-8

C

false

445

c

Bai3_1.c

// Đặng Lâm San (20170111) #include <stdio.h> #include <conio.h> #include <math.h> double Abs(double x) { if (x<0) return -x; else return x; } int main() { double x,y,z; printf("Nhap vao 3 so thuc bat ky\n"); scanf("%lf %lf %lf", &x,&y,&z); double F; F = (x+y+z)/(x*x+y*y+1)-Abs(x-z*cos(y)); printf("Gia tri cua F =%lf",F); printf("\nDANG LAM SAN 20170111"); getch(); return 0; }

0dfa8420cd3a47ccfb20926d56c22315bfb19db0

153c0ffa46ac87be61199a6f2d05ea8f30abd4f4

/lib/gmfcore/gevent.c

a1e2ae0efb280611e2336ac69c2b674db35817ec

[]

no_license

gmobi-tian/iot-gmf

b8067217ee75447f1c88d82732f9bc1c93c13923

3666d9b002208f25865331d64526ac18b3064e31

refs/heads/master

2021-01-21T21:33:23.250000

2016-06-03T10:05:10

47,596,570

0

null

UTF-8

C

false

2,656

c

gevent.c

#include "include/gevent.h" GEvent * g_event_new(gpointer sender) { GEvent * self = g_new(GEvent, 1); self->sender = sender; self->callback_list = NULL; self->data_list = NULL; self->event_firing = FALSE; self->items_to_free = NULL; return (GEvent *)self; } void g_event_free(GEvent * self) { if (self == NULL) return; if (self->callback_list != NULL) g_list_free(self->callback_list); if (self->data_list != NULL) g_list_free(self->data_list); g_free(self); } void g_event_add_listener(GEvent * self, EVENT_CALLBACK callback, gpointer data) { GList *callback_list, *data_list; g_return_if_fail(self != NULL); callback_list = self->callback_list; data_list = self->data_list; for(; callback_list != NULL; callback_list = g_list_next(callback_list), data_list = g_list_next(data_list)) { if (callback_list->data == (gpointer)callback && data_list->data == data) return; } self->callback_list = g_list_append(self->callback_list, (gpointer)callback); self->data_list = g_list_append(self->data_list, data); } void g_event_remove_listener(GEvent * self, EVENT_CALLBACK callback, gpointer data) { GList *callback_list, *data_list; g_return_if_fail(self != NULL); callback_list = self->callback_list; data_list = self->data_list; for(; callback_list != NULL; callback_list = g_list_next(callback_list), data_list = g_list_next(data_list)) { if (callback_list->data == (gpointer)callback && data_list->data == data) { self->callback_list = g_list_remove_link(self->callback_list, callback_list); self->data_list = g_list_remove_link(self->data_list, data_list); if (self->event_firing) { if (self->items_to_free == NULL) self->items_to_free = g_ptr_array_new(); g_ptr_array_add(self->items_to_free, callback_list); g_ptr_array_add(self->items_to_free, data_list); } else { g_list_free_1(callback_list); g_list_free_1(data_list); } break; } } } void g_event_fire(GEvent * self, gpointer args) { int i; GList *callback_list, *data_list; g_return_if_fail(self != NULL); callback_list = self->callback_list; data_list = self->data_list; self->event_firing = TRUE; for(; callback_list != NULL; callback_list = g_list_next(callback_list), data_list = g_list_next(data_list)) { ((EVENT_CALLBACK)callback_list->data)(self->sender, data_list->data, args); } self->event_firing = FALSE; if (self->items_to_free != NULL && g_ptr_array_length(self->items_to_free) > 0) { for(i = 0; i < g_ptr_array_length(self->items_to_free); i++) { g_list_free_1((GList*)g_ptr_array_index(self->items_to_free, i)); } g_ptr_array_set_size(self->items_to_free, 0); } }

2c46152f1f756de53a2675017404209e5c59d290

5ff4b6986e6799bc0e143e060bafc14369030d8b

/toolchain/riscv-isa-sim/riscv/insns/vwsub_wx.h

f72341ba8089e65f75d81736fd4140f0748d8ef6

[ "MIT", "LicenseRef-scancode-unknown-license-reference", "GPL-1.0-or-later", "LLVM-exception", "Apache-2.0", "BSD-3-Clause", "LicenseRef-scancode-bsd-3-clause-jtag", "GPL-3.0-or-later" ]

permissive

pulp-platform/mempool

7583204b2436cfc12ed95599463e51ad4df51557

c98fb3ada4f255623eaf9b09861f397a60c3d96b

refs/heads/main

2023-08-08T09:07:56.696000

2023-07-27T17:24:38

223,218,149

178

28

Apache-2.0

2023-07-27T17:24:39

2019-11-21T16:34:37

C

UTF-8

C

false

100

h

vwsub_wx.h

// vwsub.wx vd, vs2, rs1 VI_CHECK_DDS(false); VI_VX_LOOP_WIDEN ({ VI_WIDE_WVX_OP(rs1, -, int); })

20a8234192e6db4083e771d342c6c30bf29cb25a

ee57eff47054b37673f06f94a00c4375597f3602

/project/libraries/liblist/sources/item_next.c

b084f887f7795ee36034b0eae6113cc7195d4241

[]

no_license

damiensauv/zappy

2f69ac9ce650a34c9065ad8ca10224023a48fe32

b0c7bf64b3adf0dac531087fbbce3e437cb17758

refs/heads/master

2021-01-18T08:58:39.680000

2014-07-13T13:29:33

null

0

null

UTF-8

C

false

409

c

item_next.c

/* ** item_next.c for liblist in /home/raphy/Epitech/Libraries/liblist/sources ** ** Made by raphael defreitas ** Login <[email protected]> ** ** Started on Thu Apr 17 19:22:53 2014 raphael defreitas ** Last update Sun Jun 29 06:25:59 2014 raphael defreitas */ #include <stdlib.h> #include "list.h" t_item *item_next(t_item *this) { if (this == NULL) return (NULL); return (this->next); }

25d32b075c72aefc39cfbda785ebeaa66025846e

ab276b278dd84d1b5d2859b3093b6ed404fbd965

/bg.h

1bb8ec3993cbb1e463f9f935d92f5089e3e83526

[]

no_license

hachemba/RoadToEarth

8f0d9b9e5483e556b966eaaa569dae63bc697bd0

87dff0c98c5c742d1b99895e566697d3e17a6037

refs/heads/master

2022-10-17T16:33:33.583000

2020-06-11T14:07:47

271,327,728

0

null

UTF-8

C

false

682

h

bg.h

/** @file bg.c @brief test du code du background @date 06/06/2020 @version 1.0 @author amal */ #ifndef BG_H_INCLUDED #define BG_H_INCLUDED #include<stdio.h> #include"SDL/SDL.h" #include <stdio.h> #include <stdlib.h> #include <SDL/SDL.h> #include <stdbool.h> #include <SDL/SDL_image.h> #include <SDL/SDL_ttf.h> #include <SDL/SDL_mixer.h> typedef struct background { SDL_Surface *background; SDL_Surface *background_tile; //SDL_Rect camera; SDL_Rect posbg; }background; void initialiser_background (background *b); void afficher_background (SDL_Surface *screen,background b,SDL_Rect camera); #endif // BG_H_INCLUDED

c088e91450937df730aa66ef016ce55d4d082b6b

19a955385f0ce4e1530161c379e6bc8e14326482

/da/odas_name_info.h

085efc61c87c2b0eac588a0d149d6f944f6fd56d

[ "MIT" ]

permissive

awsdert/da

4086b9eef09f4a9560cad6113f4539e6283e0e48

9e30e9f22a6e4bd7d9e9d5bc2eb1dcda229e951f

refs/heads/master

2020-04-17T23:22:26.064000

2019-02-21T11:12:09

167,032,491

0

null

UTF-8

C

false

173

h

odas_name_info.h

#ifndef INC_ODAS_NAME_INFO #define INC_ODAS_NAME_INFO #include "odas.h" #include "odas_ucs.h" #ifndef DA_OS_MSWIN struct odas_name_info { odas_ucs_t Name; }; #endif #endif

20a69731093b1281dce2a6f60adae1cf2d564bde

922f61dbfa70d4ad86ecc67bf715e0b70969c645

/tree/tree.h

54c57ac7808ea84dd50541f6811b93593ca2fef0

[]

no_license

sumitvarude/DSA

1b436c0b9c9292ea739955c340f4098abda2296c

3309fcb3de83edce8c172c0bcd74d245056a96da

refs/heads/master

2021-01-15T11:18:39.636000

2014-01-08T09:17:54

14,852,755

0

1

null

UTF-8

C

false

373

h

tree.h

#include "../DLinked-list/iterator.h" typedef int (*compareFunc)(void* first,void* second); typedef struct { void* root; compareFunc compare; } Tree; Tree createTree(compareFunc compare); int insertTreeNode(Tree* tree,void* parent,void* data); int removeTreeNode(Tree *tree,void* data); Iterator getChildren(Tree *tree,void* parent); int search(void* tree,void* parent);

dc9a9408ae891a97e280c462df328693be64f8e9

d91ec0184f1c638ae3a28d0f7c6ac976d548ad67

/src/v1/str.c

742a6b95c8f403d8b5298567ded6b5b0ed6a28ff

[ "BSD-2-Clause" ]

permissive

riboseinc/retrace

cba06d1af0073f2630288263431f4918f373f3da

cccf46a001adaf006e5ce8c070d366966cbd4353

refs/heads/main

2022-03-06T04:34:27.418000

2022-02-09T18:18:58

2022-02-14T08:16:20

92,924,805

61

24

NOASSERTION

2022-02-17T14:52:55

2017-05-31T08:44:14

C

UTF-8

C

false

11,063

c

str.c

/* * Copyright (c) 2017, [Ribose Inc](https://www.ribose.com). * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "common.h" #include <string.h> #include "str.h" char *RETRACE_IMPLEMENTATION(strstr)(const char *s1, const char *s2) { struct rtr_event_info event_info; unsigned int parameter_types[] = {PARAMETER_TYPE_STRING, PARAMETER_TYPE_STRING, PARAMETER_TYPE_END}; void const *parameter_values[] = {&s1, &s2}; char *result = NULL; memset(&event_info, 0, sizeof(event_info)); event_info.function_name = "strstr"; event_info.function_group = RTR_FUNC_GRP_STR; event_info.parameter_types = parameter_types; event_info.parameter_values = (void **) parameter_values; event_info.return_value_type = PARAMETER_TYPE_STRING; event_info.return_value = &result; event_info.logging_level = RTR_LOG_LEVEL_NOR; retrace_log_and_redirect_before(&event_info); result = real_strstr(s1, s2); retrace_log_and_redirect_after(&event_info); return (result); } RETRACE_REPLACE(strstr, char *, (const char *s1, const char *s2), (s1, s2)) size_t RETRACE_IMPLEMENTATION(strlen)(const char *s) { size_t len; struct rtr_event_info event_info; unsigned int parameter_types[] = {PARAMETER_TYPE_STRING, PARAMETER_TYPE_END}; void const *parameter_values[] = {&s}; memset(&event_info, 0, sizeof(event_info)); event_info.function_name = "strlen"; event_info.function_group = RTR_FUNC_GRP_STR; event_info.parameter_types = parameter_types; event_info.parameter_values = (void **) parameter_values; event_info.return_value_type = PARAMETER_TYPE_INT; event_info.return_value = &len; event_info.logging_level = RTR_LOG_LEVEL_NOR; retrace_log_and_redirect_before(&event_info); len = real_strlen(s); retrace_log_and_redirect_after(&event_info); return len; } RETRACE_REPLACE(strlen, size_t, (const char *s), (s)) int RETRACE_IMPLEMENTATION(strncmp)(const char *s1, const char *s2, size_t n) { struct rtr_event_info event_info; unsigned int parameter_types[] = {PARAMETER_TYPE_STRING_LEN, PARAMETER_TYPE_STRING_LEN, PARAMETER_TYPE_INT, PARAMETER_TYPE_END}; void const *parameter_values[] = {&n, &s1, &n, &s2, &n}; int result; memset(&event_info, 0, sizeof(event_info)); event_info.function_name = "strncmp"; event_info.function_group = RTR_FUNC_GRP_STR; event_info.parameter_types = parameter_types; event_info.parameter_values = (void **) parameter_values; event_info.return_value_type = PARAMETER_TYPE_INT; event_info.return_value = &result; event_info.logging_level = RTR_LOG_LEVEL_NOR; retrace_log_and_redirect_before(&event_info); result = real_strncmp(s1, s2, n); retrace_log_and_redirect_after(&event_info); return (result); } RETRACE_REPLACE(strncmp, int, (const char *s1, const char *s2, size_t n), (s1, s2, n)) int RETRACE_IMPLEMENTATION(strcmp)(const char *s1, const char *s2) { struct rtr_event_info event_info; unsigned int parameter_types[] = {PARAMETER_TYPE_STRING, PARAMETER_TYPE_STRING, PARAMETER_TYPE_END}; void const *parameter_values[] = {&s1, &s2}; int result; memset(&event_info, 0, sizeof(event_info)); event_info.function_name = "strcmp"; event_info.function_group = RTR_FUNC_GRP_STR; event_info.parameter_types = parameter_types; event_info.parameter_values = (void **) parameter_values; event_info.return_value_type = PARAMETER_TYPE_INT; event_info.return_value = &result; event_info.logging_level = RTR_LOG_LEVEL_NOR; retrace_log_and_redirect_before(&event_info); result = real_strcmp(s1, s2); retrace_log_and_redirect_after(&event_info); return (result); } RETRACE_REPLACE(strcmp, int, (const char *s1, const char *s2), (s1, s2)) char *RETRACE_IMPLEMENTATION(strncpy)(char *s1, const char *s2, size_t n) { struct rtr_event_info event_info; unsigned int parameter_types[] = {PARAMETER_TYPE_STRING_LEN, PARAMETER_TYPE_STRING_LEN, PARAMETER_TYPE_INT, PARAMETER_TYPE_END}; void const *parameter_values[] = {&n, &s1, &n, &s2, &n}; char *result = NULL; memset(&event_info, 0, sizeof(event_info)); event_info.function_name = "strncpy"; event_info.function_group = RTR_FUNC_GRP_STR; event_info.parameter_types = parameter_types; event_info.parameter_values = (void **) parameter_values; event_info.return_value_type = PARAMETER_TYPE_STRING; event_info.return_value = &result; event_info.logging_level = RTR_LOG_LEVEL_NOR; retrace_log_and_redirect_before(&event_info); result = real_strncpy(s1, s2, n); retrace_log_and_redirect_after(&event_info); return (result); } RETRACE_REPLACE(strncpy, char *, (char *s1, const char *s2, size_t n), (s1, s2, n)) char *RETRACE_IMPLEMENTATION(strcat)(char *s1, const char *s2) { struct rtr_event_info event_info; unsigned int parameter_types[] = {PARAMETER_TYPE_STRING, PARAMETER_TYPE_STRING, PARAMETER_TYPE_END}; void const *parameter_values[] = {&s1, &s2}; char *result = NULL; memset(&event_info, 0, sizeof(event_info)); event_info.function_name = "strcat"; event_info.function_group = RTR_FUNC_GRP_STR; event_info.parameter_types = parameter_types; event_info.parameter_values = (void **) parameter_values; event_info.return_value_type = PARAMETER_TYPE_STRING; event_info.return_value = &result; event_info.logging_level = RTR_LOG_LEVEL_NOR; retrace_log_and_redirect_before(&event_info); result = real_strcat(s1, s2); retrace_log_and_redirect_after(&event_info); return (result); } RETRACE_REPLACE(strcat, char *, (char *s1, const char *s2), (s1, s2)) char *RETRACE_IMPLEMENTATION(strncat)(char *s1, const char *s2, size_t n) { char *result = NULL; struct rtr_event_info event_info; unsigned int parameter_types[] = {PARAMETER_TYPE_STRING, PARAMETER_TYPE_STRING, PARAMETER_TYPE_INT, PARAMETER_TYPE_END}; void const *parameter_values[] = {&s1, &s2, &n}; memset(&event_info, 0, sizeof(event_info)); event_info.function_name = "strncat"; event_info.function_group = RTR_FUNC_GRP_STR; event_info.parameter_types = parameter_types; event_info.parameter_values = (void **) parameter_values; event_info.return_value_type = PARAMETER_TYPE_STRING; event_info.return_value = &result; event_info.logging_level = RTR_LOG_LEVEL_NOR; retrace_log_and_redirect_before(&event_info); result = real_strncat(s1, s2, n); retrace_log_and_redirect_after(&event_info); return (result); } RETRACE_REPLACE(strncat, char *, (char *s1, const char *s2, size_t n), (s1, s2, n)) char *RETRACE_IMPLEMENTATION(strcpy)(char *s1, const char *s2) { char *result = NULL; struct rtr_event_info event_info; unsigned int parameter_types[] = {PARAMETER_TYPE_STRING, PARAMETER_TYPE_STRING, PARAMETER_TYPE_END}; void const *parameter_values[] = {&s1, &s2}; memset(&event_info, 0, sizeof(event_info)); event_info.function_name = "strcpy"; event_info.function_group = RTR_FUNC_GRP_STR; event_info.parameter_types = parameter_types; event_info.parameter_values = (void **) parameter_values; event_info.return_value_type = PARAMETER_TYPE_STRING; event_info.return_value = &result; event_info.logging_level = RTR_LOG_LEVEL_NOR; retrace_log_and_redirect_before(&event_info); result = real_strcpy(s1, s2); retrace_log_and_redirect_after(&event_info); return (result); } RETRACE_REPLACE(strcpy, char *, (char *s1, const char *s2), (s1, s2)) int RETRACE_IMPLEMENTATION(strcasecmp)(const char *s1, const char *s2) { struct rtr_event_info event_info; unsigned int parameter_types[] = {PARAMETER_TYPE_STRING, PARAMETER_TYPE_STRING, PARAMETER_TYPE_END}; void const *parameter_values[] = {&s1, &s2}; int ret; memset(&event_info, 0, sizeof(event_info)); event_info.function_name = "strcasecmp"; event_info.function_group = RTR_FUNC_GRP_STR; event_info.parameter_types = parameter_types; event_info.parameter_values = (void **) parameter_values; event_info.return_value_type = PARAMETER_TYPE_INT; event_info.return_value = &ret; event_info.logging_level = RTR_LOG_LEVEL_NOR; retrace_log_and_redirect_before(&event_info); ret = real_strcasecmp(s1, s2); retrace_log_and_redirect_after(&event_info); return (ret); } RETRACE_REPLACE(strcasecmp, int, (const char *s1, const char *s2), (s1, s2)) char *RETRACE_IMPLEMENTATION(strchr)(const char *s, int c) { char *result = NULL; struct rtr_event_info event_info; unsigned int parameter_types[] = {PARAMETER_TYPE_STRING, PARAMETER_TYPE_CHAR, PARAMETER_TYPE_END}; void const *parameter_values[] = {&s, &c}; memset(&event_info, 0, sizeof(event_info)); event_info.function_name = "strchr"; event_info.function_group = RTR_FUNC_GRP_STR; event_info.parameter_types = parameter_types; event_info.parameter_values = (void **) parameter_values; event_info.return_value_type = PARAMETER_TYPE_STRING; event_info.return_value = &result; event_info.logging_level = RTR_LOG_LEVEL_NOR; retrace_log_and_redirect_before(&event_info); result = real_strchr(s, c); retrace_log_and_redirect_after(&event_info); return (result); } RETRACE_REPLACE(strchr, char *, (const char *s, int c), (s, c)) char *RETRACE_IMPLEMENTATION(strtok)(char *str, const char *delim) { char *result = NULL; struct rtr_event_info event_info; unsigned int parameter_types[] = {PARAMETER_TYPE_STRING, PARAMETER_TYPE_STRING, PARAMETER_TYPE_END}; void const *parameter_values[] = {&str, &delim}; memset(&event_info, 0, sizeof(event_info)); event_info.function_name = "strtok"; event_info.function_group = RTR_FUNC_GRP_STR; event_info.parameter_types = parameter_types; event_info.parameter_values = (void **) parameter_values; event_info.return_value_type = PARAMETER_TYPE_STRING; event_info.return_value = &result; event_info.logging_level = RTR_LOG_LEVEL_NOR; retrace_log_and_redirect_before(&event_info); result = real_strtok(str, delim); retrace_log_and_redirect_after(&event_info); return (result); } RETRACE_REPLACE(strtok, char *, (char *str, const char *delim), (str, delim))

fcf63812b18b33db2bd41a310449b6d2b67edb30

cbec2fbe3dc9d16f140dd0de818dccb5a508733f

/examples/solv/solv.c

6a5dab7360614e61aee241bc35fbaae4f76951fd

[ "LicenseRef-scancode-warranty-disclaimer", "BSD-2-Clause" ]

permissive

jdieter/libsolv

9f0f7e9a889ebf95c0a66055a35bb43481a14b06

2234584efcc601dcb9a780b13f503cf60707782e

refs/heads/master

2020-03-18T20:02:09.946000

2018-10-08T11:24:57

135,192,308

1

0

null

2018-05-28T17:46:15

null

UTF-8

C

false

26,456

c

solv.c

/* * Copyright (c) 2009-2015, SUSE LLC. * * This program is licensed under the BSD license, read LICENSE.BSD * for further information */ /* solv, a little software installer demoing the sat solver library */ /* things it does: * - understands globs for package names / dependencies * - understands .arch suffix * - installation of commandline packages * - repository data caching * - on demand loading of secondary repository data * - gpg and checksum verification * - file conflicts * - deltarpm support * - fastestmirror implementation * * things available in the library but missing from solv: * - vendor policy loading * - multi version handling */ #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/utsname.h> #include "pool.h" #include "poolarch.h" #include "evr.h" #include "selection.h" #include "repo.h" #include "solver.h" #include "solverdebug.h" #include "transaction.h" #include "testcase.h" #ifdef SUSE #include "repo_autopattern.h" #endif #include "repoinfo.h" #include "repoinfo_cache.h" #include "repoinfo_download.h" #if defined(ENABLE_RPMDB) #include "fileprovides.h" #include "fileconflicts.h" #include "deltarpm.h" #endif #if defined(SUSE) || defined(FEDORA) || defined(MAGEIA) #include "patchjobs.h" #endif void setarch(Pool *pool) { struct utsname un; if (uname(&un)) { perror("uname"); exit(1); } pool_setarch(pool, un.machine); } int yesno(const char *str, int other) { char inbuf[128], *ip; for (;;) { printf("%s", str); fflush(stdout); *inbuf = 0; if (!(ip = fgets(inbuf, sizeof(inbuf), stdin))) { printf("Abort.\n"); exit(1); } while (*ip == ' ' || *ip == '\t') ip++; if (*ip == 'q') { printf("Abort.\n"); exit(1); } if (*ip == 'y' || *ip == 'n' || *ip == other) return *ip == 'n' ? 0 : *ip; } } #ifdef SUSE static Id nscallback(Pool *pool, void *data, Id name, Id evr) { #if 0 if (name == NAMESPACE_LANGUAGE) { if (!strcmp(pool_id2str(pool, evr), "ja")) return 1; if (!strcmp(pool_id2str(pool, evr), "de")) return 1; if (!strcmp(pool_id2str(pool, evr), "en")) return 1; if (!strcmp(pool_id2str(pool, evr), "en_US")) return 1; } #endif return 0; } #endif #ifdef SUSE static void showdiskusagechanges(Transaction *trans) { DUChanges duc[4]; int i; /* XXX: use mountpoints here */ memset(duc, 0, sizeof(duc)); duc[0].path = "/"; duc[1].path = "/usr/share/man"; duc[2].path = "/sbin"; duc[3].path = "/etc"; transaction_calc_duchanges(trans, duc, 4); for (i = 0; i < 4; i++) printf("duchanges %s: %d K %d inodes\n", duc[i].path, duc[i].kbytes, duc[i].files); } #endif static Id find_repo(const char *name, Pool *pool, struct repoinfo *repoinfos, int nrepoinfos) { const char *rp; int i; for (rp = name; *rp; rp++) if (*rp <= '0' || *rp >= '9') break; if (!*rp) { /* repo specified by number */ int rnum = atoi(name); for (i = 0; i < nrepoinfos; i++) { struct repoinfo *cinfo = repoinfos + i; if (!cinfo->enabled || !cinfo->repo) continue; if (--rnum == 0) return cinfo->repo->repoid; } } else { /* repo specified by alias */ Repo *repo; FOR_REPOS(i, repo) { if (!strcasecmp(name, repo->name)) return repo->repoid; } } return 0; } #define MODE_LIST 0 #define MODE_INSTALL 1 #define MODE_ERASE 2 #define MODE_UPDATE 3 #define MODE_DISTUPGRADE 4 #define MODE_VERIFY 5 #define MODE_PATCH 6 #define MODE_INFO 7 #define MODE_REPOLIST 8 #define MODE_SEARCH 9 void usage(int r) { fprintf(stderr, "Usage: solv COMMAND <select>\n"); fprintf(stderr, "\n"); fprintf(stderr, " dist-upgrade: replace installed packages with\n"); fprintf(stderr, " versions from the repositories\n"); fprintf(stderr, " erase: erase installed packages\n"); fprintf(stderr, " info: display package information\n"); fprintf(stderr, " install: install packages\n"); fprintf(stderr, " list: list packages\n"); fprintf(stderr, " repos: list enabled repositories\n"); fprintf(stderr, " search: search name/summary/description\n"); fprintf(stderr, " update: update installed packages\n"); fprintf(stderr, " verify: check dependencies of installed packages\n"); #if defined(SUSE) || defined(FEDORA) || defined(MAGEIA) fprintf(stderr, " patch: install newest maintenance updates\n"); #endif fprintf(stderr, "\n"); exit(r); } int main(int argc, char **argv) { Pool *pool; Repo *commandlinerepo = 0; Id *commandlinepkgs = 0; Id p; struct repoinfo *repoinfos, installedrepoinfo; int nrepoinfos = 0; int mainmode = 0, mode = 0; int i, newpkgs; Queue job, checkq; Solver *solv = 0; Transaction *trans; FILE **newpkgsfps; Queue repofilter; Queue kindfilter; Queue archfilter; int archfilter_src = 0; int cleandeps = 0; int forcebest = 0; char *rootdir = 0; char *keyname = 0; int keyname_depstr = 0; int keyname_alldeps = 0; /* dnf repoquesy --alldeps */ int debuglevel = 0; int answer, acnt = 0; char *testcase = 0; argc--; argv++; while (argc && !strcmp(argv[0], "-d")) { debuglevel++; argc--; argv++; } if (!argv[0]) usage(1); if (!strcmp(argv[0], "install") || !strcmp(argv[0], "in")) { mainmode = MODE_INSTALL; mode = SOLVER_INSTALL; } #if defined(SUSE) || defined(FEDORA) || defined(MAGEIA) else if (!strcmp(argv[0], "patch")) { mainmode = MODE_PATCH; mode = SOLVER_INSTALL; } #endif else if (!strcmp(argv[0], "erase") || !strcmp(argv[0], "rm")) { mainmode = MODE_ERASE; mode = SOLVER_ERASE; } else if (!strcmp(argv[0], "list") || !strcmp(argv[0], "ls")) { mainmode = MODE_LIST; mode = 0; } else if (!strcmp(argv[0], "info")) { mainmode = MODE_INFO; mode = 0; } else if (!strcmp(argv[0], "search") || !strcmp(argv[0], "se")) { mainmode = MODE_SEARCH; mode = 0; } else if (!strcmp(argv[0], "verify")) { mainmode = MODE_VERIFY; mode = SOLVER_VERIFY; } else if (!strcmp(argv[0], "update") || !strcmp(argv[0], "up")) { mainmode = MODE_UPDATE; mode = SOLVER_UPDATE; } else if (!strcmp(argv[0], "dist-upgrade") || !strcmp(argv[0], "dup")) { mainmode = MODE_DISTUPGRADE; mode = SOLVER_DISTUPGRADE; } else if (!strcmp(argv[0], "repos") || !strcmp(argv[0], "repolist") || !strcmp(argv[0], "lr")) { mainmode = MODE_REPOLIST; mode = 0; } else usage(1); for (;;) { if (argc > 2 && !strcmp(argv[1], "--root")) { rootdir = argv[2]; argc -= 2; argv += 2; } else if (argc > 1 && !strcmp(argv[1], "--clean")) { cleandeps = 1; argc--; argv++; } else if (argc > 1 && !strcmp(argv[1], "--best")) { forcebest = 1; argc--; argv++; } else if (argc > 1 && !strcmp(argv[1], "--alldeps")) { keyname_alldeps = 1; /* dnf repoquesy --alldeps */ argc--; argv++; } else if (argc > 1 && !strcmp(argv[1], "--depstr")) { keyname_depstr = 1; /* do literal matching instead of dep intersection */ argc--; argv++; } else if (argc > 2 && !strcmp(argv[1], "--keyname")) { keyname = argv[2]; argc -= 2; argv += 2; } else if (argc > 2 && !strcmp(argv[1], "--testcase")) { testcase = argv[2]; argc -= 2; argv += 2; } else break; } set_userhome(); pool = pool_create(); pool_set_rootdir(pool, rootdir); #if 0 { const char *langs[] = {"de_DE", "de", "en"}; pool_set_languages(pool, langs, sizeof(langs)/sizeof(*langs)); } #endif pool_setloadcallback(pool, load_stub, 0); #ifdef SUSE pool->nscallback = nscallback; #endif if (debuglevel) pool_setdebuglevel(pool, debuglevel); setarch(pool); pool_set_flag(pool, POOL_FLAG_ADDFILEPROVIDESFILTERED, 1); repoinfos = read_repoinfos(pool, &nrepoinfos); sort_repoinfos(repoinfos, nrepoinfos); if (mainmode == MODE_REPOLIST) { int j = 1; for (i = 0; i < nrepoinfos; i++) { struct repoinfo *cinfo = repoinfos + i; if (!cinfo->enabled) continue; printf("%d: %-20s %s (prio %d)\n", j++, cinfo->alias, cinfo->name, cinfo->priority); } exit(0); } memset(&installedrepoinfo, 0, sizeof(installedrepoinfo)); if (!read_installed_repo(&installedrepoinfo, pool)) exit(1); read_repos(pool, repoinfos, nrepoinfos); /* setup filters */ queue_init(&repofilter); queue_init(&kindfilter); queue_init(&archfilter); while (argc > 1) { if (!strcmp(argv[1], "-i")) { queue_push2(&repofilter, SOLVER_SOLVABLE_REPO | SOLVER_SETREPO, pool->installed->repoid); argc--; argv++; } else if (argc > 2 && (!strcmp(argv[1], "-r") || !strcmp(argv[1], "--repo"))) { Id repoid = find_repo(argv[2], pool, repoinfos, nrepoinfos); if (!repoid) { fprintf(stderr, "%s: no such repo\n", argv[2]); exit(1); } /* SETVENDOR is actually wrong but useful */ queue_push2(&repofilter, SOLVER_SOLVABLE_REPO | SOLVER_SETREPO | SOLVER_SETVENDOR, repoid); argc -= 2; argv += 2; } else if (argc > 2 && !strcmp(argv[1], "--arch")) { if (!strcmp(argv[2], "src") || !strcmp(argv[2], "nosrc")) archfilter_src = 1; queue_push2(&archfilter, SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, 0, pool_str2id(pool, argv[2], 1), REL_ARCH, 1)); argc -= 2; argv += 2; } else if (argc > 2 && (!strcmp(argv[1], "-t") || !strcmp(argv[1], "--type"))) { const char *kind = argv[2]; if (!strcmp(kind, "srcpackage")) { /* hey! should use --arch! */ queue_push2(&archfilter, SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, 0, ARCH_SRC, REL_ARCH, 1)); archfilter_src = 1; argc -= 2; argv += 2; continue; } if (!strcmp(kind, "package")) kind = ""; if (!strcmp(kind, "all")) queue_push2(&kindfilter, SOLVER_SOLVABLE_ALL, 0); else queue_push2(&kindfilter, SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, 0, pool_str2id(pool, kind, 1), REL_KIND, 1)); argc -= 2; argv += 2; } else break; } if (mainmode == MODE_SEARCH) { Queue sel, q; Dataiterator di; if (argc != 2) usage(1); pool_createwhatprovides(pool); queue_init(&sel); dataiterator_init(&di, pool, 0, 0, 0, argv[1], SEARCH_SUBSTRING|SEARCH_NOCASE); dataiterator_set_keyname(&di, SOLVABLE_NAME); dataiterator_set_search(&di, 0, 0); while (dataiterator_step(&di)) queue_push2(&sel, SOLVER_SOLVABLE, di.solvid); dataiterator_set_keyname(&di, SOLVABLE_SUMMARY); dataiterator_set_search(&di, 0, 0); while (dataiterator_step(&di)) queue_push2(&sel, SOLVER_SOLVABLE, di.solvid); dataiterator_set_keyname(&di, SOLVABLE_DESCRIPTION); dataiterator_set_search(&di, 0, 0); while (dataiterator_step(&di)) queue_push2(&sel, SOLVER_SOLVABLE, di.solvid); dataiterator_free(&di); if (repofilter.count) selection_filter(pool, &sel, &repofilter); if (archfilter.count) selection_filter(pool, &sel, &archfilter); if (kindfilter.count) selection_filter(pool, &sel, &kindfilter); queue_init(&q); selection_solvables(pool, &sel, &q); queue_free(&sel); for (i = 0; i < q.count; i++) { Solvable *s = pool_id2solvable(pool, q.elements[i]); printf(" - %s [%s]: %s\n", pool_solvable2str(pool, s), s->repo->name, solvable_lookup_str(s, SOLVABLE_SUMMARY)); } queue_free(&q); exit(0); } /* process command line packages */ if (mainmode == MODE_LIST || mainmode == MODE_INFO || mainmode == MODE_INSTALL) { for (i = 1; i < argc; i++) { if (!is_cmdline_package((const char *)argv[i])) continue; if (access(argv[i], R_OK)) { perror(argv[i]); exit(1); } if (!commandlinepkgs) commandlinepkgs = solv_calloc(argc, sizeof(Id)); if (!commandlinerepo) commandlinerepo = repo_create(pool, "@commandline"); p = add_cmdline_package(commandlinerepo, (const char *)argv[i]); if (!p) { fprintf(stderr, "could not add '%s'\n", argv[i]); exit(1); } commandlinepkgs[i] = p; } if (commandlinerepo) { repo_internalize(commandlinerepo); #ifdef SUSE repo_add_autopattern(commandlinerepo, 0); #endif } } #if defined(ENABLE_RPMDB) if (pool->disttype == DISTTYPE_RPM) addfileprovides(pool); #endif pool_createwhatprovides(pool); if (keyname) keyname = solv_dupjoin("solvable:", keyname, 0); queue_init(&job); for (i = 1; i < argc; i++) { Queue job2; int flags, rflags; if (commandlinepkgs && commandlinepkgs[i]) { queue_push2(&job, SOLVER_SOLVABLE, commandlinepkgs[i]); continue; } queue_init(&job2); flags = SELECTION_NAME|SELECTION_PROVIDES|SELECTION_GLOB; flags |= SELECTION_CANON|SELECTION_DOTARCH|SELECTION_REL; if (kindfilter.count) flags |= SELECTION_SKIP_KIND; if (mode == MODE_LIST || archfilter_src) flags |= SELECTION_WITH_SOURCE; if (argv[i][0] == '/') flags |= SELECTION_FILELIST | (mode == MODE_ERASE ? SELECTION_INSTALLED_ONLY : 0); if (keyname && keyname_depstr) flags |= SELECTION_MATCH_DEPSTR; if (!keyname || keyname_alldeps) rflags = selection_make(pool, &job2, argv[i], flags); else rflags = selection_make_matchdeps(pool, &job2, argv[i], flags, pool_str2id(pool, keyname, 1), 0); if (repofilter.count) selection_filter(pool, &job2, &repofilter); if (archfilter.count) selection_filter(pool, &job2, &archfilter); if (kindfilter.count) selection_filter(pool, &job2, &kindfilter); if (!job2.count) { flags |= SELECTION_NOCASE; if (!keyname || keyname_alldeps) rflags = selection_make(pool, &job2, argv[i], flags); else rflags = selection_make_matchdeps(pool, &job2, argv[i], flags, pool_str2id(pool, keyname, 1), 0); if (repofilter.count) selection_filter(pool, &job2, &repofilter); if (archfilter.count) selection_filter(pool, &job2, &archfilter); if (kindfilter.count) selection_filter(pool, &job2, &kindfilter); if (job2.count) printf("[ignoring case for '%s']\n", argv[i]); } if (!job2.count) { fprintf(stderr, "nothing matches '%s'\n", argv[i]); exit(1); } if (rflags & SELECTION_FILELIST) printf("[using file list match for '%s']\n", argv[i]); if (rflags & SELECTION_PROVIDES) printf("[using capability match for '%s']\n", argv[i]); if (keyname && keyname_alldeps) { Queue q; queue_init(&q); selection_solvables(pool, &job2, &q); selection_make_matchsolvablelist(pool, &job2, &q, 0, pool_str2id(pool, keyname, 1), 0); queue_free(&q); } queue_insertn(&job, job.count, job2.count, job2.elements); queue_free(&job2); } keyname = solv_free(keyname); if (!job.count && (mainmode == MODE_UPDATE || mainmode == MODE_DISTUPGRADE || mainmode == MODE_VERIFY || repofilter.count || archfilter.count || kindfilter.count)) { queue_push2(&job, SOLVER_SOLVABLE_ALL, 0); if (repofilter.count) selection_filter(pool, &job, &repofilter); if (archfilter.count) selection_filter(pool, &job, &archfilter); if (kindfilter.count) selection_filter(pool, &job, &kindfilter); } queue_free(&repofilter); queue_free(&archfilter); queue_free(&kindfilter); if (!job.count && mainmode != MODE_PATCH) { printf("no package matched\n"); exit(1); } if (mainmode == MODE_LIST || mainmode == MODE_INFO) { /* list mode, no solver needed */ Queue q; queue_init(&q); for (i = 0; i < job.count; i += 2) { int j; queue_empty(&q); pool_job2solvables(pool, &q, job.elements[i], job.elements[i + 1]); for (j = 0; j < q.count; j++) { Solvable *s = pool_id2solvable(pool, q.elements[j]); if (mainmode == MODE_INFO) { const char *str; printf("Name: %s\n", pool_solvable2str(pool, s)); printf("Repo: %s\n", s->repo->name); printf("Summary: %s\n", solvable_lookup_str(s, SOLVABLE_SUMMARY)); str = solvable_lookup_str(s, SOLVABLE_URL); if (str) printf("Url: %s\n", str); str = solvable_lookup_str(s, SOLVABLE_LICENSE); if (str) printf("License: %s\n", str); printf("Description:\n%s\n", solvable_lookup_str(s, SOLVABLE_DESCRIPTION)); printf("\n"); } else { #if 1 const char *sum = solvable_lookup_str_lang(s, SOLVABLE_SUMMARY, "de", 1); #else const char *sum = solvable_lookup_str_poollang(s, SOLVABLE_SUMMARY); #endif printf(" - %s [%s]\n", pool_solvable2str(pool, s), s->repo->name); if (sum) printf(" %s\n", sum); } } } queue_free(&q); queue_free(&job); pool_free(pool); free_repoinfos(repoinfos, nrepoinfos); solv_free(commandlinepkgs); exit(0); } #if defined(SUSE) || defined(FEDORA) || defined(MAGEIA) if (mainmode == MODE_PATCH) add_patchjobs(pool, &job); #endif // add mode for (i = 0; i < job.count; i += 2) { job.elements[i] |= mode; if (mode == SOLVER_UPDATE && pool_isemptyupdatejob(pool, job.elements[i], job.elements[i + 1])) job.elements[i] ^= SOLVER_UPDATE ^ SOLVER_INSTALL; if (cleandeps) job.elements[i] |= SOLVER_CLEANDEPS; if (forcebest) job.elements[i] |= SOLVER_FORCEBEST; } #if 0 // multiversion test queue_push2(&job, SOLVER_MULTIVERSION|SOLVER_SOLVABLE_PROVIDES, pool_str2id(pool, "multiversion(kernel)", 1)); #endif #if 0 queue_push2(&job, SOLVER_INSTALL|SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, NAMESPACE_LANGUAGE, 0, REL_NAMESPACE, 1)); queue_push2(&job, SOLVER_ERASE|SOLVER_CLEANDEPS|SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, NAMESPACE_LANGUAGE, 0, REL_NAMESPACE, 1)); #endif rerunsolver: solv = solver_create(pool); solver_set_flag(solv, SOLVER_FLAG_SPLITPROVIDES, 1); #if 0 solver_set_flag(solv, SOLVER_FLAG_IGNORE_RECOMMENDED, 1); #endif #if defined(FEDORA) || defined(MAGEIA) solver_set_flag(solv, SOLVER_FLAG_ALLOW_VENDORCHANGE, 1); #endif if (mainmode == MODE_ERASE) solver_set_flag(solv, SOLVER_FLAG_ALLOW_UNINSTALL, 1); /* don't nag */ solver_set_flag(solv, SOLVER_FLAG_BEST_OBEY_POLICY, 1); for (;;) { Id problem, solution; int pcnt, scnt; pcnt = solver_solve(solv, &job); if (testcase) { printf("Writing solver testcase:\n"); if (!testcase_write(solv, testcase, TESTCASE_RESULT_TRANSACTION | TESTCASE_RESULT_PROBLEMS, 0, 0)) printf("%s\n", pool_errstr(pool)); testcase = 0; } if (!pcnt) break; pcnt = solver_problem_count(solv); printf("Found %d problems:\n", pcnt); for (problem = 1; problem <= pcnt; problem++) { int take = 0; printf("Problem %d/%d:\n", problem, pcnt); solver_printprobleminfo(solv, problem); printf("\n"); scnt = solver_solution_count(solv, problem); for (solution = 1; solution <= scnt; solution++) { printf("Solution %d:\n", solution); solver_printsolution(solv, problem, solution); printf("\n"); } for (;;) { char inbuf[128], *ip; printf("Please choose a solution: "); fflush(stdout); *inbuf = 0; if (!(ip = fgets(inbuf, sizeof(inbuf), stdin))) { printf("Abort.\n"); exit(1); } while (*ip == ' ' || *ip == '\t') ip++; if (*ip >= '0' && *ip <= '9') { take = atoi(ip); if (take >= 1 && take <= scnt) break; } if (*ip == 's') { take = 0; break; } if (*ip == 'q') { printf("Abort.\n"); exit(1); } } if (!take) continue; solver_take_solution(solv, problem, take, &job); } } trans = solver_create_transaction(solv); if (!trans->steps.count) { printf("Nothing to do.\n"); transaction_free(trans); solver_free(solv); queue_free(&job); pool_free(pool); free_repoinfos(repoinfos, nrepoinfos); solv_free(commandlinepkgs); exit(1); } /* display transaction to the user and ask for confirmation */ printf("\n"); printf("Transaction summary:\n\n"); transaction_print(trans); #if defined(SUSE) showdiskusagechanges(trans); #endif printf("install size change: %d K\n", transaction_calc_installsizechange(trans)); printf("\n"); acnt = solver_alternatives_count(solv); if (acnt) { if (acnt == 1) printf("Have one alternative:\n"); else printf("Have %d alternatives:\n", acnt); for (i = 1; i <= acnt; i++) { Id id, from; int atype = solver_get_alternative(solv, i, &id, &from, 0, 0, 0); printf(" - %s\n", solver_alternative2str(solv, atype, id, from)); } printf("\n"); answer = yesno("OK to continue (y/n/a)? ", 'a'); } else answer = yesno("OK to continue (y/n)? ", 0); if (answer == 'a') { Queue choicesq; Queue answerq; Id id, from, chosen; int j; queue_init(&choicesq); queue_init(&answerq); for (i = 1; i <= acnt; i++) { int atype = solver_get_alternative(solv, i, &id, &from, &chosen, &choicesq, 0); printf("\n%s\n", solver_alternative2str(solv, atype, id, from)); for (j = 0; j < choicesq.count; j++) { Id p = choicesq.elements[j]; if (p < 0) p = -p; queue_push(&answerq, p); printf("%6d: %s\n", answerq.count, pool_solvid2str(pool, p)); } } queue_free(&choicesq); printf("\n"); for (;;) { char inbuf[128], *ip; int neg = 0; printf("OK to continue (y/n), or number to change alternative: "); fflush(stdout); *inbuf = 0; if (!(ip = fgets(inbuf, sizeof(inbuf), stdin))) { printf("Abort.\n"); exit(1); } while (*ip == ' ' || *ip == '\t') ip++; if (*ip == '-' && ip[1] >= '0' && ip[1] <= '9') { neg = 1; ip++; } if (*ip >= '0' && *ip <= '9') { int take = atoi(ip); if (take > 0 && take <= answerq.count) { Id p = answerq.elements[take - 1]; queue_free(&answerq); queue_push2(&job, (neg ? SOLVER_DISFAVOR : SOLVER_FAVOR) | SOLVER_SOLVABLE_NAME, pool->solvables[p].name); solver_free(solv); solv = 0; goto rerunsolver; break; } } if (*ip == 'n' || *ip == 'y') { answer = *ip == 'n' ? 0 : *ip; break; } } queue_free(&answerq); } if (!answer) { printf("Abort.\n"); transaction_free(trans); solver_free(solv); queue_free(&job); pool_free(pool); free_repoinfos(repoinfos, nrepoinfos); solv_free(commandlinepkgs); exit(1); } /* download all new packages */ queue_init(&checkq); newpkgs = transaction_installedresult(trans, &checkq); newpkgsfps = 0; if (newpkgs) { int downloadsize = 0; for (i = 0; i < newpkgs; i++) { Solvable *s; p = checkq.elements[i]; s = pool_id2solvable(pool, p); downloadsize += solvable_lookup_sizek(s, SOLVABLE_DOWNLOADSIZE, 0); } printf("Downloading %d packages, %d K\n", newpkgs, downloadsize); newpkgsfps = solv_calloc(newpkgs, sizeof(*newpkgsfps)); for (i = 0; i < newpkgs; i++) { const char *loc; Solvable *s; struct repoinfo *cinfo; p = checkq.elements[i]; s = pool_id2solvable(pool, p); if (s->repo == commandlinerepo) { loc = solvable_lookup_location(s, 0); if (!loc) continue; if (!(newpkgsfps[i] = fopen(loc, "r"))) { perror(loc); exit(1); } putchar('.'); continue; } cinfo = s->repo->appdata; if (!cinfo || cinfo->type == TYPE_INSTALLED) { printf("%s: no repository information\n", s->repo->name); exit(1); } loc = solvable_lookup_location(s, 0); if (!loc) continue; /* pseudo package? */ #if defined(ENABLE_RPMDB) if (pool->installed && pool->installed->nsolvables) { if ((newpkgsfps[i] = trydeltadownload(s, loc)) != 0) { putchar('d'); fflush(stdout); continue; /* delta worked! */ } } #endif if ((newpkgsfps[i] = downloadpackage(s, loc)) == 0) { printf("\n%s: %s not found in repository\n", s->repo->name, loc); exit(1); } putchar('.'); fflush(stdout); } putchar('\n'); } #if defined(ENABLE_RPMDB) && (defined(SUSE) || defined(FEDORA) || defined(MANDRIVA) || defined(MAGEIA)) /* check for file conflicts */ if (newpkgs) { Queue conflicts; queue_init(&conflicts); if (checkfileconflicts(pool, &checkq, newpkgs, newpkgsfps, &conflicts)) { if (yesno("Re-run solver (y/n/q)? ", 0)) { for (i = 0; i < newpkgs; i++) if (newpkgsfps[i]) fclose(newpkgsfps[i]); newpkgsfps = solv_free(newpkgsfps); solver_free(solv); solv = 0; pool_add_fileconflicts_deps(pool, &conflicts); queue_free(&conflicts); goto rerunsolver; } } queue_free(&conflicts); } #endif /* and finally commit the transaction */ printf("Committing transaction:\n\n"); transaction_order(trans, 0); for (i = 0; i < trans->steps.count; i++) { int j; FILE *fp; Id type; p = trans->steps.elements[i]; type = transaction_type(trans, p, SOLVER_TRANSACTION_RPM_ONLY); switch(type) { case SOLVER_TRANSACTION_ERASE: printf("erase %s\n", pool_solvid2str(pool, p)); commit_transactionelement(pool, type, p, 0); break; case SOLVER_TRANSACTION_INSTALL: case SOLVER_TRANSACTION_MULTIINSTALL: printf("install %s\n", pool_solvid2str(pool, p)); for (j = 0; j < newpkgs; j++) if (checkq.elements[j] == p) break; fp = j < newpkgs ? newpkgsfps[j] : 0; if (!fp) continue; commit_transactionelement(pool, type, p, fp); fclose(fp); newpkgsfps[j] = 0; break; default: break; } } for (i = 0; i < newpkgs; i++) if (newpkgsfps[i]) fclose(newpkgsfps[i]); solv_free(newpkgsfps); queue_free(&checkq); transaction_free(trans); solver_free(solv); queue_free(&job); pool_free(pool); free_repoinfos(repoinfos, nrepoinfos); solv_free(commandlinepkgs); exit(0); }

967cbbb57c98f8b6cd47a5a90d03d40c91a2633e

b6c008b671fa8e735c89fa7836ede44d498f9e75

/TP_04_Canepa/Canepa_TP_04/getUTN.c

5b3aa09a108b35640964a3ef8f5b28271d43fb2a

[]

no_license

sacanepa/tp_laboratorio_1

d0a0028597358a1d3fe7f759f782a03aa449e412

8e3f4b77afe9765a96628523387551e47e4a83c2

refs/heads/master

2021-01-21T04:50:33.239000

2016-06-22T01:43:41

54,387,083

0

null

UTF-8

C

false

6,925

c

getUTN.c

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <ctype.h> #include "getUTN.h" /** \brief desplega menu y solicita una opcion * \param item Es el texto desplegado en el menu * \return devuelve un entero que representa la opción elegida * */ int menu (char* item) { int choice; //Almacena la opción del menú elegida por el usuario printf(item); printf("\n\nSeleccione una opci%cn: ", 162); scanf("%d",&choice); return choice; } /** * \brief Solicita un número al usuario y lo valida * \param input Se carga el numero ingresado * \param message Es el mensaje a ser mostrado * \param eMessage Es el mensaje a ser mostrado en caso de error * \param lowLimit Limite inferior a validar * \param hiLimit Limite superior a validar * \return Si obtuvo el numero [0] si no [-1] * */ int getInt(int* input,char message[],char eMessage[], int lowLimit, int hiLimit) { int i=0; do { if (i!=0) { printf("%s",eMessage); if (validaS_N() == 1 && i<3) { printf("%s",message); scanf("%d",input); } else { return -1; } } else { printf("%s",message); scanf("%d",input); } i++; } while (*input < lowLimit || *input > hiLimit); //*input = 44; return 0; } /** * \brief Solicita un número al usuario y lo valida * \param input Se carga el numero ingresado * \param message Es el mensaje a ser mostrado * \param eMessage Es el mensaje a ser mostrado en caso de error * \param lowLimit Limite inferior a validar * \param hiLimit Limite superior a validar * \return Si obtuvo el numero [0] si no [-1] * */ int getDate(long int* pDate,char message[]) { int wDay, wMonth, wYear; if (getInt(&wDay,"Ingrese el dia (DD): ","Error. Formato DD.", 01, 31) == 0) { if (getInt(&wMonth,"Ingrese el mes (MM): ","Error. Formato MM.", 01, 12) == 0) { if (getInt(&wYear,"Ingrese el dia (YYYY): ","Error. Formato YYYY.", 1900, 2999) == 0) { *pDate = (long)wDay + ((long)wMonth * 100) + ((long)wYear * 10000); return 0; }else { return -1; } }else { return -1; } }else { return -1; } return -1; } /** * \brief Solicita un número al usuario y lo valida * \param input Se carga el numero ingresado * \param message Es el mensaje a ser mostrado * \param eMessage Es el mensaje a ser mostrado en caso de error * \param lowLimit Limite inferior a validar * \param hiLimit Limite superior a validar * \return Si obtuvo el numero [0] si no [-1] * */ int getLongInt(long int* input,char message[],char eMessage[],long int lowLimit,long int hiLimit) { /* int i=0; do { if (i!=0) { printf("%s",eMessage); if (validaS_N() == 1 && i<3) { printf("%s",message); scanf("%ld",input); } else { return -1; } } else { printf("%s",message); scanf("%ld",input); } i++; } while (*input < lowLimit || *input > hiLimit); */ //*input = 44; return 0; } /** * \brief Solicita un número al usuario y lo valida * \param input Se carga el numero ingresado * \param message Es el mensaje a ser mostrado * \param eMessage Es el mensaje a ser mostrado en caso de error * \param lowLimit Limite inferior a validar * \param hiLimit Limite superior a validar * \return Si obtuvo el numero [0] si no [-1] * */ int getFloat(float* input,char message[],char eMessage[], float lowLimit, float hiLimit) { int i=0; do { if (i!=0) { printf("%s",eMessage); if (validaS_N() == 1 && i<3) { printf("%s",message); scanf("%f",input); } else { return -1; } } else { printf("%s",message); scanf("%f",input); } i++; } while (*input < lowLimit || *input > hiLimit); //*input = 1234.88; return 0; } /** * \brief Solicita un número al usuario y lo valida * \param input Se carga el numero ingresado * \param message Es el mensaje a ser mostrado * \param eMessage Es el mensaje a ser mostrado en caso de error * \param lowLimit Limite inferior a validar * \param hiLimit Limite superior a validar * \return Si obtuvo el numero [0] si no [-1] * */ int getAvg(float* input1,float* input2,float *solution) { *solution = *input1 / *input2; return 0; } /** * \brief Solicita una cadena de caracteres al usuario y la valida * \param input Se carga el string ingresado * \param message Es el mensaje a ser mostrado * \param eMessage Es el mensaje a ser mostrado en caso de error * \param lowLimit Longitud mÃnima de la cadena * \param hiLimit Longitud mÃ¡xima de la cadena * \return Si obtuvo la cadena [0] si no [-1] * */ int getString(char* input,char message[],char eMessage[], int lowLimit, int hiLimit) { int i=0; char buffer[1024]; int nbrChar; do { if (i!=0) { printf("%s",eMessage); if (validaS_N() == 1 && i<3) { printf("%s",message); fflush(stdin); gets(buffer); nbrChar=strlen(buffer); } else { return -1; } } else { printf("%s",message); fflush(stdin); gets(buffer); nbrChar=strlen(buffer); } i++; } while (nbrChar < lowLimit || nbrChar > hiLimit); strcpy(input,buffer); return 0; } int validaS_N(void) { char respuesta; int i; printf("Ingresa de nuevo? S/N?"); fflush(stdin); scanf("%c", &respuesta); respuesta = toupper(respuesta); i=0; while(respuesta != 'S' && respuesta != 'N' && i<3){ printf("ERROR REINGRESE, Continua S/N?"); fflush(stdin); scanf("%c", &respuesta); respuesta = toupper(respuesta); i++; } if(respuesta == 'S'){ return 1; } else{ return 0; } } int validaDecision(char message[]) { char respuesta; int i; printf("%s",message); fflush(stdin); scanf("%c", &respuesta); respuesta = toupper(respuesta); i=0; while(respuesta != 'S' && respuesta != 'N' && i<3){ printf("ERROR REINGRESE, Continua S/N?"); fflush(stdin); scanf("%c", &respuesta); respuesta = toupper(respuesta); i++; } if(respuesta == 'S'){ return 0; } else{ return -1; } }

548c340df12472810094a9646a14d4b881b0620c

8553ff106e88fb5c263664b4337984530a4c479b

/LCS.c

1f4dfd63105c943263309a1402b1626c0fed628d

[]

no_license

kartikmanaguli/DataStructureAndAlgorithms

d53e87d57bd33f4a27e83e2034f1f491afcc7a4b

e87a3098b546535935d44c6ffe2d4b6875e936e7

refs/heads/master

2021-08-16T01:39:40.267000

2021-07-23T11:15:39

246,648,388

0

null

UTF-8

C

false

1,289

c

LCS.c

/* -------------------------------------------------------------------------------------------------------------------------- THE LONGEST COMMON SUBSEQUENT ALGORITM (MEMORY EFFICIENT) USING DYNAMIC PROGRAMMING APPROACH (BOTTOM-UP APPROACH) AUTHOR : KARTIK MANGULI, SOFTWARE DEVELOPER WIPRO LTD. -------------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<stdlib.h> int max(int variable1, int variable2) { return (variable1<variable2?variable2:variable1);} void main() { char *x,*y; int **c; int n,m,i,j; printf("Enter The Size Of String A\n"); scanf("%d",&n); x=(char*) malloc(n*sizeof(char)); printf("Enter The String A:\n"); scanf("%s",x); printf("Enter The Size Of String B\n"); scanf("%d",&m); y=(char*) malloc(m*sizeof(char)); printf("Enter The String B\n"); scanf("%s",y); m++,n++; c = (int **)malloc(m*sizeof(int*)); c[0] = (int *) malloc(m*n*sizeof(int)) ; for(i=0;i<=m;i++) c[i]=c[0]+i*n; for(i=1;i<m;i++) { for(j=1;j<n;j++) { if(y[i-1]==x[j-1]) c[i][j] = 1+c[i-1][j-1]; else c[i][j]=max(c[i-1][j],c[i][j-1]); } } printf("The Longest Common Sub Sequence is :%d",c[m-1][n-1]); }

27195c836d8d41316fb058ab60878a5b71b5014f

08875e634d7f8c704f32a9e11c8ed99a3f7849c9

/include/md.h

1c63fc865710689e74c1dada6d8afd4f2a54a093

[]

no_license

Hypo-Li/glToy

8de93f0fd6e13ac4a15a267ec637f08d967f0389

fbbd4a5fc7ea7eddcd015c9a7fbe827f79fb2764

refs/heads/master

2022-11-30T20:08:46.880000

2020-08-14T12:44:19

null

0

null

WINDOWS-1252

C

false

2,764

h

md.h

#pragma once #include <glm/glm.hpp> #include <typedef.h> enum TextureType { TEXTURE_TYPE_AMBIENT = 0x0, TEXTURE_TYPE_DIFFUSE = 0x1, TEXTURE_TYPE_SPECULAR = 0x2, TEXTURE_TYPE_NORMALS = 0x3, TEXTURE_TYPE_HEIGHT = 0x4, }; const DWORD BONE_NUM_PER_VERTEX = 4; const DWORD STATIC_MESH_SIZE = 24; const DWORD VERTEX_SIZE = 56; const DWORD WEIGHT_VERTEX_SIZE = VERTEX_SIZE + 8 * BONE_NUM_PER_VERTEX; const DWORD FACE_SIZE = 12; const DWORD TEXTURE_SIZE = 8; const DWORD ANIM_MESH_SIZE = 32; const DWORD BONE_SIZE = 76; const DWORD WEIGHT_SIZE = 8; const DWORD BONE_NODE_SIZE = 16; const DWORD ANIM_SIZE = 16; const DWORD BONE_ANIM_SIZE = 28; const DWORD POS_FRAME_SIZE = 16; const DWORD ROT_FRAME_SIZE = 20; const DWORD SCA_FRAME_SIZE = 16; /* typedef struct Vertex { glm::vec3 position; glm::vec3 normals; glm::vec3 tangent; glm::vec3 bitangent; glm::vec2 texCoords; }Vertex; //56byte typedef struct WeightVertex { glm::vec3 position; glm::vec3 normals; glm::vec3 tangent; glm::vec3 bitangent; glm::vec2 texCoords; DWORD bone[]; float weight[]; }WeightVertex; typedef struct Face { DWORD indexes[3]; }Face; //12byte enum TextureType { TEXTURE_TYPE_AMBIENT = 0x0, TEXTURE_TYPE_DIFFUSE = 0x1, TEXTURE_TYPE_SPECULAR = 0x2, TEXTURE_TYPE_NORMALS = 0x3, TEXTURE_TYPE_HEIGHT = 0x4, }; typedef struct Texture { TextureType type; DWORD offset; }Texture; //8byte typedef struct StaticMesh { DWORD numVertex; DWORD vertexOffset; DWORD numFace; DWORD faceOffset; DWORD numTexture; DWORD textureOffset; }StaticMesh; //24byte typedef struct Bone { DWORD id; DWORD numWeight; DWORD weightOffset; glm::mat4 offsetMat; }Bone; //76byte typedef struct Weight { DWORD indexes; float weight; }Weight; //8byte typedef struct AnimMesh { DWORD numVertex; DWORD vertexOffset; DWORD numFace; DWORD faceOffset; DWORD numTexture; DWORD textureOffset; DWORD numBone; DWORD boneOffset; }AnimMesh; //32byte typedef struct BoneNode { DWORD id; DWORD parentNodeID; DWORD numChildren; DWORD childrenNodeID; }BoneNode; //16byte typedef struct Anim { DWORD fps; DWORD numFrame; DWORD numBoneAnim; DWORD boneAnimOffset; }Anim; //16byte typedef struct BoneAnim { DWORD id; DWORD numPositionKeyFrame; DWORD PositionKeyFrameOffset; DWORD numRotationKeyFrame; DWORD RotationKeyFrameOffset; DWORD numScalingKeyFrame; DWORD ScalingKeyFrameOffset; }BoneAnim; //28byte typedef struct PositionKeyFrame { DWORD timeStamp; glm::vec3 position; }PositionKeyFrame; //16byte typedef struct RotationKeyFrame { DWORD timeStamp; glm::vec4 rotation; //ËÄÔªÊý }RotationKeyFrame; //20byte typedef struct ScalingKeyFrame { DWORD timeStamp; glm::vec3 scaling; }ScalingKeyFrame; //16byte */

97e389021a5526b2ea985503f52f09e2b27c3e15

440a7caaf14c75c3a2bd3f8337fc3ade4bca4da8

/TP 3/1.minimum.c

e8722c89b4fcd10968c3aebc4a9f4d04f94a2df8

[]

no_license

ly-hourt/TP

c284a260619f17eba3b60db188ff7795c9b16b2f

ba9bad538f788db49973471a013922f3974c6170

refs/heads/master

2022-07-05T13:32:56.700000

2020-05-15T17:42:23

264,257,804

0

null

UTF-8

C

false

1,344

c

1.minimum.c

#include<stdio.h> int main() { int num1 ,num2 ,num3,num4,num5,num6,num7; printf("Enter your the 7 numbers : "); scanf("%d%d%d%d%d%d%d",&num1 ,&num2 ,&num3,&num4,&num5,&num6,&num7); if(num1<num2&&num1<num3&&num1<num4&&num1<num5&&num1<num6&&num1<num7) { printf("The biggest number is : %d.",num1); } else if(num2<num1&&num2<num3&&num2<num4&&num2<num5&&num2<num6&&num2<num7) { printf("The biggest number is : %d.",num2); } else if(num3<num1&&num3<num2&&num4<num4&&num3<num5&&num3<num6&&num3<num7) { printf("The biggest number is : %d.",num3); } else if(num4<num1&&num4<num3&&num4<num2&&num4<num5&&num4<num6&&num4<num7) { printf("The biggest number is : %d.",num4); } else if(num5<num1&&num5<num3&&num5<num4&&num5<num2&&num5<num6&&num5<num7) { printf("The biggest number is : %d.",num5); } else if(num6<num1&&num6<num3&&num6<num4&&num6<num5&&num6<num2&&num6<num7) { printf("The biggest number is : %d.",num6); } else if(num7<num1&&num7<num3&&num7<num4&&num7<num5&&num7<num6&&num7<num2) { printf("The biggest number is : %d.",num7); } else { printf("The input : %d %d %d %d %d %d %d is error ",num1 ,num2 ,num3,num4,num5,num6,num7); } }

b357d303078754dc2e017c99e86f2ba1392a5e53

bbf3855ea8fcd83922c70b6a9234e0c3125c497e

/src/fifo.c

8e842e195c47be4d661e90efe133b4b360d1851e

[]

no_license

N3U2O/CFIFO

8dc2e768b813db08803701f287e49890d19b3829

bc468e39f52a8c71a7f5fa5005022b4fc2865d1e

refs/heads/master

2021-01-18T15:21:40.231000

2015-10-14T19:04:46

24,559,743

0

null

UTF-8

C

false

7,842

c

fifo.c

//- -------------------------------------------------------------------------- //! \file fifo.c //! \brief A FIFO implementation using circular buffer with stored last //! operation. The main file tests the functionality of the FIFO. //! \author Adrian Gugyin //! \date 28/09/2014 //- -------------------------------------------------------------------------- #include <stdio.h> #include <stdbool.h> #include <stdint.h> #include <string.h> #include <time.h> // Turn on debug messages #define _DEBUG_ // Version (VERMAJOR.VERMINOR[.BUILD_ID]) #define VERMAJOR 0 #define VERMINOR 1 #define BUILD 1 // Macro contants #define NFIFOCAP 4 #define NITEMS 6 #define NNAMESIZE 20 //- -------------------------------------------------------------------------- //! \brief FIFO entry structure definiton //- -------------------------------------------------------------------------- struct FifoEntry { uint8_t ID; char Name [NNAMESIZE]; clock_t TimeStamp; }; // FIFO entry typedef typedef struct FifoEntry FifoEntry_t; //- -------------------------------------------------------------------------- //! \brief FIFO structure definiton //- -------------------------------------------------------------------------- struct Fifo { FifoEntry_t data [NFIFOCAP]; // statically allocated array for entries FifoEntry_t *pRd; // read pointer FifoEntry_t *pWr; // write pointer bool fRd; // last operation, true if it was a read }; // FIFO typedef typedef struct Fifo Fifo_t; // Global function prototypes bool FifoInit(Fifo_t *pFifo); bool FifoPut(Fifo_t *pFifo, FifoEntry_t item); bool FifoGet(Fifo_t *pFifo, FifoEntry_t *pItem); bool testFIFO(void); #ifdef _DEBUG_ // For debug purposes, compile the file "dump.c" for a hexadecimal dump // to list the contents of \c length bytes of memory starting from address // \c addr with an optional constant string description \c desc extern void hexDump(const char* desc, void* addr, uint32_t length); #endif //= ========================================================================== //! //! MAIN //! //= ========================================================================== int main(void) { printf("FIFO demo v%d.%d\n" "==============\n\n", VERMAJOR, VERMINOR); testFIFO(); return 0; } //= ========================================================================== //! //! END OF MAIN //! //= ========================================================================== // Main test function for the FIFO bool testFIFO(void) { uint8_t idx; // run index for the loop to make entries Fifo_t fifo; // the FIFO structure clock_t tick0 = clock(); // reference time [CPU clocks] set here FifoInit(&fifo); // initialize the FIFO #ifdef _DEBUG_ printf("[DEBUG]: Size of FIFO: %d\n\n", (uint32_t)sizeof(fifo)); #endif for (idx = 0; idx < NITEMS; idx++) { uint8_t eIdx = idx + 1; char eName [NNAMESIZE]; // We have to be careful when assigning names, that's why we use the // function snprintf to put a formatted literal into the eName string. snprintf(eName, NNAMESIZE-1, "( entry [%d] )", eIdx); // Create a temporary FIFO entry item which we'll put into the FIFO FifoEntry_t item; // Set its members, starting with ID: item.ID = eIdx; // Name (using strncpy to safely assign strings to one another): strncpy(item.Name, eName, sizeof(item.Name)); // and the TimeStamp [in CPU ticks elapsed since the reference time]: item.TimeStamp = clock() - tick0; #ifdef _DEBUG_ printf("[DEBUG]: timestamp for entry #(%d) is %f seconds.\n", eIdx, ((float) item.TimeStamp)/CLOCKS_PER_SEC ); printf("[DEBUG]: entry #(%d) data: { %d, \"%s\", %d }\n", eIdx, item.ID, item.Name, item.TimeStamp); #endif if (FifoPut(&fifo, item)) printf("FifoPut successful!\n"); else printf("FifoPut unsuccessful, the FIFO is probably full.\n"); } #ifdef _DEBUG_ #define NMSGLEN 40 { char msg[NMSGLEN]; snprintf(msg, NMSGLEN-1, "[DEBUG]: FIFO (start address %08X) dump", (uint64_t)&fifo); hexDump(msg, &fifo, (uint32_t)sizeof(fifo)); } #undef NMSGLEN #endif printf("\n"); // Get items from FIFO for (idx = 0; idx < NITEMS; idx++) { FifoEntry_t e; if (FifoGet(&fifo, &e)) printf("FifoGet successful! Got { %d, \"%s\", %d }\n", e.ID, e.Name, e.TimeStamp); else printf("FifoGet unsuccessful, the FIFO is probably empty.\n"); } } //- -------------------------------------------------------------------------- //! \brief FIFO initialization //! \desc Sets a default entry, then sets the read and write pointers to //! match the inital address of the FIFO's circular buffer that is //! at the beginning of the statically allocated arrays RAM location. //! It order to start with an empty FIFO, the function sets the last //! operation to "read" (fRd <- true). //! \param [in] //! pFifo : FIFO address //! \return //! Type : bool //! Value : true, if initalization was successful //- -------------------------------------------------------------------------- bool FifoInit(Fifo_t *pFifo) { FifoEntry_t defaultEntry = {0, "DEFAULT", clock()}; pFifo->pRd = pFifo->data; pFifo->pWr = pFifo->data; // Set last operation to "read" to indicate FIFO is empty. pFifo->fRd = true; return true; } //- -------------------------------------------------------------------------- //! \brief Put an entry to the FIFO end (pointed by pWr) //! \param [in] //! pFifo : FIFO address //! item : FIFO entry item //! \return //! Type : bool //! Value : true, if write was successful (ie. the FIFO wasn't full) //- -------------------------------------------------------------------------- bool FifoPut(Fifo_t *pFifo, FifoEntry_t item) { // If the last operation wasn't a read and the read and write pointers // coincide, the FIFO is full, we have to reject the 'put' request. if (!pFifo->fRd && pFifo->pWr==pFifo->pRd) return false; // Copy the item to the current write location and update the pointer *pFifo->pWr++ = item; pFifo->fRd = false; // update last operation // If we've reached the end of the buffer, reset pWr to the start location. if (pFifo->pWr >= pFifo->data + NFIFOCAP) pFifo->pWr = pFifo->data; return true; } //- -------------------------------------------------------------------------- //! \brief Get an entry from the FIFO start (pointed by pRd) //! \param [in] //! pFifo : FIFO address //! \param [out] //! pItem : FIFO entry item //! \return //! Type : bool //! Value : true, if read was successful (ie. the FIFO wasn't empty) //- -------------------------------------------------------------------------- bool FifoGet(Fifo_t *pFifo, FifoEntry_t *pItem) { // If the last operation was a read and the read and write pointers // coincide, the FIFO is empty, no item to get, so reject the request. if (pFifo->fRd && pFifo->pWr==pFifo->pRd) return false; // Copy the item from current read location and update the pointer *pItem = *pFifo->pRd++; pFifo->fRd = true; // update last operation // If we've reached the end of the buffer, reset pRd to the start location. if (pFifo->pRd >= pFifo->data + NFIFOCAP) pFifo->pRd = pFifo->data; return true; }

9894ee315425b883f9d4c4c08cac24894fcc65f9

1375cc7e1bd596fa6a449f58aa4dd4a9d718f240

/netWorkSocketProgram/1thNetworkBook/6Chapters/server/server.c

e7d1d357734d4bdd525d88b562e1dc07fc1777ec

[]

no_license

Skin---yang/StudyCode

c09697ed654a793c7711d9af8f51ffb0396948e1

824e939141bed5599ae11794093f2cd19e8fe2eb

refs/heads/master

2021-01-15T11:58:18.807000

2017-11-02T10:20:06

99,637,276

0

null

UTF-8

C

false

3,284

c

server.c

#include "../../comm/unp.h" // this is a base sever // this server use select deal with the client connect. void ServerBase() { int sevSocket, i; struct sockaddr_in serveraddr; int transSocket, connSocket; int nready, client[FD_SETSIZE]; fd_set reset, allset; int maxfd, maxi; char buf[MAXLINE]; bzero(buf, MAXLINE); //create sevSocket = socket(AF_INET, SOCK_STREAM, 0); if(sevSocket < 0) err_quit("sevSocket fail\n"); bzero(&serveraddr, sizeof(serveraddr)); serveraddr.sin_family = AF_INET; // if not use the htons function, the server will bind * port. serveraddr.sin_port = htons(SERV_PORT); // INADDR_ANY mean is 0.0.0.0 because a server can have multiple networks cards. serveraddr.sin_addr.s_addr = INADDR_ANY; if(bind(sevSocket, (const struct sockaddr*)&serveraddr, sizeof(serveraddr)) < 0) err_quit("bind fail\n"); listen(sevSocket, LISTENQ); maxfd = sevSocket; maxi = -1; // the variable is mean client arrary maximum index. // init for(i = 0; i < FD_SETSIZE; ++i) { client[i] = -1; } FD_ZERO(&allset); FD_SET(sevSocket, &allset); while(1) { reset = allset; nready = select(maxfd+1, &reset, NULL, NULL, NULL); if(nready == -1) err_quit("function select fail.\n"); if(FD_ISSET(sevSocket, &reset)) { transSocket = accept(sevSocket, NULL, NULL); if(nready == -1) { err_quit("function select fail.\n"); } for(i = 0; i < FD_SETSIZE; ++i) { if(client[i] < 0) { client[i] = transSocket; break; } } if(i == FD_SETSIZE) { err_quit("not have enough descriptot"); } FD_SET(transSocket, &allset); if(i > maxi) maxi = i; // update the maximum if(transSocket > maxfd) maxfd = transSocket; if(--nready <= 0) continue; } // check all client for data for(i = 0; i <= maxi; ++i) { if((connSocket = client[i]) < 0) continue; // clear the buf bzero(buf, MAXLINE); if(FD_ISSET(connSocket, &reset)) { if(read(connSocket, buf, MAXLINE) == 0) { // close and clear the socket close(connSocket); FD_CLR(connSocket, &allset); client[i] = -1; } else { char sendbuf[MAXLINE]; sprintf(sendbuf, "server: %s", buf); //print the server data puts(buf); // answer the client. write(connSocket, sendbuf, sizeof(buf)); } // not have more socket if(--nready <= 0) break; } } } } int main(int argc, char **argv) { ServerBase(); return 0; }

58493daffd4692cd6b57ace892007b54a4844695

74a44e5174847a60c747428a9271a234954163a2

/SquiLu-ext/sq_axtls.c

67573d8801b2a068d60b72e2250c93d9e3edba4b

[]

no_license

mingodad/squilu

8bc74484d0af7c5c5a66cb577e1feeebc9ce9774

ef96bae1f0b226737367c3ad662de2526fd58a65

refs/heads/master

2022-12-10T06:56:55.251000

2022-12-08T17:31:36

33,980,799

81

15

null

UTF-8

C

false

15,349

c

sq_axtls.c

#ifdef __cplusplus extern "C" { #endif #ifdef USE_AXTLS #include "squirrel.h" #include <string.h> #include <stdio.h> #include <stdlib.h> /* for malloc */ #include <assert.h> /* for a few sanity tests */ #include "os_port.h" #include "ssl.h" #include "crypto.h" static const SQChar SQ_LIBNAME[] = _SC("axtls"); static const SQChar ssl_ctx_NAME[] = _SC("ssl_ctx"); static const SQChar ssl_NAME[] = _SC("ssl"); SQ_OPT_STRING_STRLEN(); static const SQChar SSL_CTX_Tag[] = _SC("sq_axtls_ssl_ctx"); #define GET_ssl_ctx_INSTANCE() SQ_GET_INSTANCE(v, 1, SSL_CTX, SSL_CTX_Tag) \ if(self == NULL) return sq_throwerror(v, _SC("ssl_ctx object already closed")); static const SQChar SSL_Tag[] = _SC("sq_axtls_ssl"); #define GET_ssl_INSTANCE() SQ_GET_INSTANCE(v, 1, SSL, SSL_Tag) \ if(self == NULL) return sq_throwerror(v, _SC("ssl object already closed")); static SQRESULT ssl_release_hook(SQUserPointer p, SQInteger size, void *ep) { SSL *self = (SSL*)p; if(self) ssl_free(self); return 0; } static SQRESULT sq_ssl_free(HSQUIRRELVM v) { SQ_FUNC_VARS_NO_TOP(v); GET_ssl_INSTANCE(); ssl_release_hook(self, 0, v); sq_setinstanceup(v, 1, 0); return 0; } static SQRESULT ssl_constructor(HSQUIRRELVM v, SSL *ssl, int free_on_gc) { if(!ssl) return sq_throwerror(v, _SC("Could'nt create an ssl object.")); sq_pushstring(v, SQ_LIBNAME, -1); if(sq_getonroottable(v) == SQ_OK){ sq_pushstring(v, ssl_NAME, -1); if(sq_get(v, -2) == SQ_OK){ if(sq_createinstance(v, -1) == SQ_OK){ sq_setinstanceup(v, -1, ssl); if(free_on_gc) sq_setreleasehook(v,-1, ssl_release_hook); return 1; } } } return SQ_ERROR; } static SQRESULT sq_ssl_read(HSQUIRRELVM v){ SQ_FUNC_VARS(v); GET_ssl_INSTANCE(); SQ_OPT_INTEGER(v, 2, count, 0); uint8_t *in_data = NULL; int result = ssl_read(self, &in_data, count); if (result > SSL_OK) sq_pushstring(v, (const SQChar*)in_data, result); else sq_pushinteger(v, result); return 1; } static SQRESULT sq_ssl_write(HSQUIRRELVM v){ SQ_FUNC_VARS(v); GET_ssl_INSTANCE(); SQ_GET_STRING(v, 2, out_data); if(_top_ > 2) { SQ_GET_INTEGER(v, 3, size); if(size > out_data_size) return sq_throwerror(v, _SC("parameter 2 size bigger than data size")); out_data_size = size; } sq_pushinteger(v, ssl_write(self, (const uint8_t *)out_data, out_data_size)); return 1; } static SQRESULT sq_ssl_get_session_id(HSQUIRRELVM v){ SQ_FUNC_VARS_NO_TOP(v); GET_ssl_INSTANCE(); const uint8_t * result = ssl_get_session_id(self); sq_pushstring(v, (char *)result, ssl_get_session_id_size(self)); return 1; } static SQRESULT sq_ssl_get_session_id_size(HSQUIRRELVM v){ SQ_FUNC_VARS_NO_TOP(v); GET_ssl_INSTANCE(); uint8_t result = ssl_get_session_id_size(self); sq_pushinteger(v, result); return 1; } static SQRESULT sq_ssl_get_cipher_id(HSQUIRRELVM v){ SQ_FUNC_VARS_NO_TOP(v); GET_ssl_INSTANCE(); uint8_t result = ssl_get_cipher_id(self); sq_pushinteger(v, result); return 1; } static SQRESULT sq_ssl_handshake_status(HSQUIRRELVM v){ SQ_FUNC_VARS_NO_TOP(v); GET_ssl_INSTANCE(); int result = ssl_handshake_status(self); sq_pushinteger(v, result); return 1; } static SQRESULT sq_ssl_verify_cert(HSQUIRRELVM v){ SQ_FUNC_VARS_NO_TOP(v); GET_ssl_INSTANCE(); int result = ssl_verify_cert(self); sq_pushinteger(v, result); return 1; } static SQRESULT sq_ssl_get_cert_dn(HSQUIRRELVM v){ SQ_FUNC_VARS_NO_TOP(v); GET_ssl_INSTANCE(); SQ_GET_INTEGER(v, 2, component); const char* result = ssl_get_cert_dn(self, component); sq_pushstring(v, result, -1); return 1; } static SQRESULT sq_ssl_get_cert_subject_alt_dnsname(HSQUIRRELVM v){ SQ_FUNC_VARS_NO_TOP(v); GET_ssl_INSTANCE(); SQ_GET_INTEGER(v, 2, dnsindex); const char* result = ssl_get_cert_subject_alt_dnsname(self, dnsindex); sq_pushstring(v, result, -1); return 1; } static SQRESULT sq_ssl_renegotiate(HSQUIRRELVM v){ SQ_FUNC_VARS_NO_TOP(v); GET_ssl_INSTANCE(); int result = ssl_renegotiate(self); sq_pushinteger(v, result); return 1; } static SQRESULT sq_ssl_ctx_server_new(HSQUIRRELVM v){ SQ_FUNC_VARS_NO_TOP(v); GET_ssl_ctx_INSTANCE(); SQ_GET_INTEGER(v, 2, client_fd); SSL *ssl = ssl_server_new(self, client_fd); SQRESULT rc = ssl_constructor(v, ssl, 1); if(rc == SQ_ERROR && ssl){ ssl_free(ssl); } return rc; } static SQRESULT sq_ssl_ctx_client_new(HSQUIRRELVM v){ SQ_FUNC_VARS(v); GET_ssl_ctx_INSTANCE(); SQ_GET_INTEGER(v, 2, client_fd); SQ_OPT_STRING(v, 3, session_id, NULL); SQ_OPT_INTEGER(v, 4, size, -1); SSL *ssl = ssl_client_new(self, client_fd, (const uint8_t *)session_id, size >= 0 ? size : session_id_size, NULL); SQRESULT rc = ssl_constructor(v, ssl, 1); if(rc == SQ_ERROR && ssl){ ssl_free(ssl); } return rc; } static SQRESULT sq_ssl_ctx_find(HSQUIRRELVM v){ SQ_FUNC_VARS_NO_TOP(v); GET_ssl_ctx_INSTANCE(); SQ_GET_INTEGER(v, 2, client_fd); SSL *ssl = ssl_find(self, client_fd); if(ssl) return ssl_constructor(v, ssl, 0); else sq_pushnull(v); return 1; } static SQRESULT sq_ssl_ctx_obj_load(HSQUIRRELVM v){ SQ_FUNC_VARS_NO_TOP(v); GET_ssl_ctx_INSTANCE(); SQ_GET_INTEGER(v, 2, obj_type); SQ_GET_STRING(v, 3, filename); SQ_GET_STRING(v, 4, password); int result = ssl_obj_load(self, obj_type, filename, password); sq_pushinteger(v, result); return 1; } static SQRESULT sq_ssl_ctx_obj_memory_load(HSQUIRRELVM v){ SQ_FUNC_VARS_NO_TOP(v); GET_ssl_ctx_INSTANCE(); SQ_GET_INTEGER(v, 2, obj_type); SQ_GET_STRING(v, 3, data); SQ_GET_STRING(v, 4, password); int result = ssl_obj_memory_load(self, obj_type, (const uint8_t *)data, data_size, password); sq_pushinteger(v, result); return 1; } static SQRESULT sq_axtls_version(HSQUIRRELVM v){ sq_pushstring(v,(const char*)ssl_version(), -1); return 1; } static SQRESULT sq_axtls_get_config(HSQUIRRELVM v){ SQ_FUNC_VARS_NO_TOP(v); SQ_GET_INTEGER(v, 2, info); sq_pushinteger(v, ssl_get_config(info)); return 1; } static SQRESULT sq_axtls_display_error(HSQUIRRELVM v){ SQ_FUNC_VARS_NO_TOP(v); SQ_GET_INTEGER(v, 2, error); ssl_display_error(error); return 0; } static SQRESULT sq_axtls_get_error(HSQUIRRELVM v){ SQ_FUNC_VARS_NO_TOP(v); SQ_GET_INTEGER(v, 2, error); SQInteger buff_size = 250; SQChar *buff = sq_getscratchpad(v, buff_size); sq_pushstring(v, ssl_get_error(error, buff, buff_size), -1); return 1; } static SQRESULT ssl_ctx_release_hook(SQUserPointer p, SQInteger size, void *ep) { SSL_CTX *self = (SSL_CTX*)p; if(self) ssl_ctx_free(self); return 0; } static SQRESULT sq_ssl_ctx_free(HSQUIRRELVM v) { SQ_FUNC_VARS_NO_TOP(v); GET_ssl_ctx_INSTANCE(); ssl_ctx_release_hook(self, 0, v); sq_setinstanceup(v, 1, 0); return 0; } static SQRESULT sq_ssl_ctx_constructor(HSQUIRRELVM v) { SQInteger options, num_sessions; sq_getinteger(v, 2, &options); sq_getinteger(v, 3, &num_sessions); SSL_CTX *ssl_ctx = ssl_ctx_new(options, num_sessions); if(!ssl_ctx) return sq_throwerror(v, _SC("Could'nt create an ssl context.")); sq_setinstanceup(v, 1, ssl_ctx); sq_setreleasehook(v,1, ssl_ctx_release_hook); return 1; } // Stringify binary data. Output buffer must be twice as big as input, // because each byte takes 2 bytes in string representation void sq_axtls_bin2str(char *to, const unsigned char *p, size_t len) { static const char *hex = "0123456789abcdef"; for (; len--; p++) { *to++ = hex[p[0] >> 4]; *to++ = hex[p[0] & 0x0f]; } *to = '\0'; } static SQRESULT sq_axtls_md5(HSQUIRRELVM v) { SQ_FUNC_VARS(v); char buf[(MD5_SIZE*2)+1]; unsigned char hash[MD5_SIZE]; MD5_CTX ctx; MD5_Init(&ctx); for (int i = 2; i <= _top_; ++i) { SQ_GET_STRING(v, i, p); MD5_Update(&ctx, (const unsigned char *) p, p_size); } MD5_Final(hash, &ctx); sq_axtls_bin2str(buf, hash, sizeof(hash)); sq_pushstring(v, buf, -1); return 1; } static SQRESULT sq_axtls_sha1(HSQUIRRELVM v) { SQ_FUNC_VARS(v); char buf[(SHA1_SIZE*2)+1]; unsigned char hash[SHA1_SIZE]; SHA1_CTX ctx; SHA1_Init(&ctx); for (int i = 2; i <= _top_; ++i) { SQ_GET_STRING(v, i, p); SHA1_Update(&ctx, (const unsigned char *) p, p_size); } SHA1_Final(hash, &ctx); sq_axtls_bin2str(buf, hash, sizeof(hash)); sq_pushstring(v, buf, -1); return 1; } static SQRESULT sq_axtls_sha256(HSQUIRRELVM v) { SQ_FUNC_VARS(v); char buf[(SHA256_SIZE*2)+1]; unsigned char hash[SHA256_SIZE]; SHA256_CTX ctx; SHA256_Init(&ctx); for (int i = 2; i <= _top_; ++i) { SQ_GET_STRING(v, i, p); SHA256_Update(&ctx, (const unsigned char *) p, p_size); } SHA256_Final(hash, &ctx); sq_axtls_bin2str(buf, hash, sizeof(hash)); sq_pushstring(v, buf, -1); return 1; } static SQRESULT sq_axtls_rng_initialize(HSQUIRRELVM v) { RNG_initialize(); return 0; } static SQRESULT sq_axtls_rng_terminate(HSQUIRRELVM v) { RNG_terminate(); return 0; } typedef int (*get_random_fptr_t)(int, uint8_t*); static SQRESULT sq_axtls_get_random0(HSQUIRRELVM v, get_random_fptr_t grf) { SQ_FUNC_VARS_NO_TOP(v); SQ_GET_INTEGER(v, 2, length); if(length < 1) return sq_throwerror(v, _SC("Minimun length error " _PRINT_INT_FMT), length); if(!RNG_is_initialized()) return sq_throwerror(v, _SC("Need to call rng_initialize first")); SQChar *buff = sq_getscratchpad(v, length); (*grf)(length, buff); sq_pushstring(v, buff, length); return 1; } static SQRESULT sq_axtls_get_random(HSQUIRRELVM v) { return sq_axtls_get_random0(v, get_random); } static SQRESULT sq_axtls_get_random_nz(HSQUIRRELVM v) { return sq_axtls_get_random0(v, get_random_NZ); } #define _DECL_AXTLS_FUNC(name,nparams,pmask) {_SC(#name),sq_axtls_##name,nparams,pmask} static SQRegFunction axtls_obj_funcs[]={ _DECL_AXTLS_FUNC(get_config,2,_SC(".i")), _DECL_AXTLS_FUNC(display_error,2,_SC(".i")), _DECL_AXTLS_FUNC(get_error,2,_SC(".i")), _DECL_AXTLS_FUNC(version,1,_SC(".")), _DECL_AXTLS_FUNC(md5,-2,_SC(".s")), _DECL_AXTLS_FUNC(sha1,-2,_SC(".s")), _DECL_AXTLS_FUNC(sha256,-2,_SC(".s")), _DECL_AXTLS_FUNC(rng_initialize,1,_SC(".")), _DECL_AXTLS_FUNC(rng_terminate,1,_SC(".")), _DECL_AXTLS_FUNC(get_random,2,_SC(".i")), _DECL_AXTLS_FUNC(get_random_nz,2,_SC(".i")), {0,0} }; #undef _DECL_AXTLS_FUNC #define _DECL_SSL_CTX_FUNC(name,nparams,pmask) {_SC(#name),sq_ssl_ctx_##name,nparams,pmask} static SQRegFunction ssl_ctx_obj_funcs[]={ _DECL_SSL_CTX_FUNC(constructor,3,_SC("xii")), _DECL_SSL_CTX_FUNC(free,1,_SC("x")), _DECL_SSL_CTX_FUNC(server_new,2,_SC("xi")), _DECL_SSL_CTX_FUNC(client_new,-2,_SC("xisi")), _DECL_SSL_CTX_FUNC(find,2,_SC("xs")), _DECL_SSL_CTX_FUNC(obj_load,2,_SC("xs")), _DECL_SSL_CTX_FUNC(obj_memory_load,2,_SC("xs")), {0,0} }; #undef _DECL_SSL_CTX_FUNC #define _DECL_SSL_FUNC(name,nparams,pmask) {_SC(#name),sq_ssl_##name,nparams,pmask} static SQRegFunction ssl_obj_funcs[]={ _DECL_SSL_FUNC(free,1,_SC("x")), _DECL_SSL_FUNC(read,-1,_SC("xi")), _DECL_SSL_FUNC(write,-2,_SC("xsi")), _DECL_SSL_FUNC(get_session_id,1,_SC("x")), _DECL_SSL_FUNC(get_session_id_size,1,_SC("x")), _DECL_SSL_FUNC(get_cipher_id,1,_SC("x")), _DECL_SSL_FUNC(handshake_status,1,_SC("x")), _DECL_SSL_FUNC(verify_cert,1,_SC("x")), _DECL_SSL_FUNC(get_cert_dn,2,_SC("xi")), _DECL_SSL_FUNC(get_cert_subject_alt_dnsname,2,_SC("xi")), _DECL_SSL_FUNC(renegotiate,1,_SC("x")), {0,0} }; #undef _DECL_SSL_FUNC typedef struct { const SQChar *Str; SQInteger Val; } KeyIntType, * KeyIntPtrType; static KeyIntType axtls_constants[] = { #define MK_CONST(c) {_SC(#c), c} MK_CONST(SSL_SESSION_ID_SIZE), MK_CONST(SSL_CLIENT_AUTHENTICATION), MK_CONST(SSL_SERVER_VERIFY_LATER), MK_CONST(SSL_NO_DEFAULT_KEY), MK_CONST(SSL_DISPLAY_STATES), MK_CONST(SSL_DISPLAY_BYTES), MK_CONST(SSL_DISPLAY_CERTS), MK_CONST(SSL_DISPLAY_RSA), MK_CONST(SSL_CONNECT_IN_PARTS), MK_CONST(SSL_OK), MK_CONST(SSL_NOT_OK), MK_CONST(SSL_ERROR_DEAD), MK_CONST(SSL_CLOSE_NOTIFY), MK_CONST(SSL_ERROR_CONN_LOST), MK_CONST(SSL_ERROR_SOCK_SETUP_FAILURE), MK_CONST(SSL_ERROR_INVALID_HANDSHAKE), MK_CONST(SSL_ERROR_INVALID_PROT_MSG), MK_CONST(SSL_ERROR_INVALID_HMAC), MK_CONST(SSL_ERROR_INVALID_VERSION), MK_CONST(SSL_ERROR_INVALID_SESSION), MK_CONST(SSL_ERROR_NO_CIPHER), MK_CONST(SSL_ERROR_BAD_CERTIFICATE), MK_CONST(SSL_ERROR_INVALID_KEY), MK_CONST(SSL_ERROR_FINISHED_INVALID), MK_CONST(SSL_ERROR_NO_CERT_DEFINED), MK_CONST(SSL_ERROR_NO_CLIENT_RENOG), MK_CONST(SSL_ERROR_NOT_SUPPORTED), MK_CONST(SSL_X509_OFFSET), MK_CONST(SSL_ALERT_TYPE_WARNING), MK_CONST(SLL_ALERT_TYPE_FATAL), MK_CONST(SSL_ALERT_CLOSE_NOTIFY), MK_CONST(SSL_ALERT_UNEXPECTED_MESSAGE), MK_CONST(SSL_ALERT_BAD_RECORD_MAC), MK_CONST(SSL_ALERT_HANDSHAKE_FAILURE), MK_CONST(SSL_ALERT_BAD_CERTIFICATE), MK_CONST(SSL_ALERT_ILLEGAL_PARAMETER), MK_CONST(SSL_ALERT_DECODE_ERROR), MK_CONST(SSL_ALERT_DECRYPT_ERROR), MK_CONST(SSL_ALERT_INVALID_VERSION), MK_CONST(SSL_ALERT_NO_RENEGOTIATION), MK_CONST(SSL_AES128_SHA), MK_CONST(SSL_AES256_SHA), MK_CONST(SSL_BUILD_SKELETON_MODE), MK_CONST(SSL_BUILD_SERVER_ONLY), MK_CONST(SSL_BUILD_ENABLE_VERIFICATION), MK_CONST(SSL_BUILD_ENABLE_CLIENT), MK_CONST(SSL_BUILD_FULL_MODE), MK_CONST(SSL_BUILD_MODE), MK_CONST(SSL_MAX_CERT_CFG_OFFSET), MK_CONST(SSL_MAX_CA_CERT_CFG_OFFSET), MK_CONST(SSL_HAS_PEM), MK_CONST(SSL_DEFAULT_SVR_SESS), MK_CONST(SSL_DEFAULT_CLNT_SESS), MK_CONST(SSL_X509_CERT_COMMON_NAME), MK_CONST(SSL_X509_CERT_ORGANIZATION), MK_CONST(SSL_X509_CERT_ORGANIZATIONAL_NAME), MK_CONST(SSL_X509_CA_CERT_COMMON_NAME), MK_CONST(SSL_X509_CA_CERT_ORGANIZATION), MK_CONST(SSL_X509_CA_CERT_ORGANIZATIONAL_NAME), MK_CONST(SSL_OBJ_X509_CERT), MK_CONST(SSL_OBJ_X509_CACERT), MK_CONST(SSL_OBJ_RSA_KEY), MK_CONST(SSL_OBJ_PKCS8), MK_CONST(SSL_OBJ_PKCS12), {0,0} }; /* This defines a function that opens up your library. */ SQRESULT sqext_register_axtls (HSQUIRRELVM v) { //add a namespace axtls sq_pushstring(v, SQ_LIBNAME, -1); sq_newtable(v); sq_insert_reg_funcs(v, axtls_obj_funcs); //add constants KeyIntPtrType KeyIntPtr; for (KeyIntPtr = axtls_constants; KeyIntPtr->Str; KeyIntPtr++) { sq_pushstring(v, KeyIntPtr->Str, -1); //first the key sq_pushinteger(v, KeyIntPtr->Val); //then the value sq_newslot(v, -3, SQFalse); //store then } //now create the SSL Context class sq_pushstring(v,ssl_ctx_NAME,-1); sq_newclass(v,SQFalse); sq_settypetag(v,-1,(void*)SSL_CTX_Tag); sq_insert_reg_funcs(v, ssl_ctx_obj_funcs); sq_newslot(v,-3,SQFalse); //now create the SSL class sq_pushstring(v,ssl_NAME,-1); sq_newclass(v,SQFalse); sq_settypetag(v,-1,(void*)SSL_Tag); sq_insert_reg_funcs(v, ssl_obj_funcs); sq_newslot(v,-3,SQFalse); sq_newslot(v,-3,SQFalse); //add axtls table to the root table return SQ_OK; } #ifdef __cplusplus } #endif //USE_AXTLS #endif

5135e6fc5f8193701a99da84450e231dab2585e0

fcddd423d14a62a1fe1de3fb53abf3155b044b59

/test/t/t_comb.c

07994b5f713cd6aa5bab2837df89f86ab649060e

[ "MIT" ]

permissive

theisro/Soundpipe

f39b098a30d4d21fff99b1dc788fe0aefe12f7a0

a7f029d212c4868daa92b38203afd63f8f0b2dd7

refs/heads/master

2021-04-15T06:50:26.725000

2018-03-26T04:54:43

126,774,733

2

0

MIT

2018-03-26T04:49:14

null

UTF-8

C

false

1,163

c

t_comb.c

#include "soundpipe.h" #include "md5.h" #include "tap.h" #include "test.h" typedef struct { sp_comb *comb; sp_tenv *env; sp_noise *nz; } UserData; int t_comb(sp_test *tst, sp_data *sp, const char *hash) { sp_srand(sp, 0); uint32_t n; int fail = 0; SPFLOAT tick = 0, env = 0, noise = 0, comb = 0; UserData ud; sp_comb_create(&ud.comb); sp_tenv_create(&ud.env); sp_noise_create(&ud.nz); sp_comb_init(sp, ud.comb, 0.01); sp_tenv_init(sp, ud.env); ud.env->atk = 0.001; ud.env->hold = 0.00; ud.env->rel = 0.1; sp_noise_init(sp, ud.nz); for(n = 0; n < tst->size; n++) { tick = 0, env = 0, noise = 0, comb = 0; tick = (sp->pos == 0) ? 1 : 0; sp_tenv_compute(sp, ud.env, &tick, &env); sp_noise_compute(sp, ud.nz, NULL, &noise); noise *= env * 0.5; sp_comb_compute(sp, ud.comb, &noise, &comb); sp_test_add_sample(tst, comb); } fail = sp_test_verify(tst, hash); sp_noise_destroy(&ud.nz); sp_tenv_destroy(&ud.env); sp_comb_destroy(&ud.comb); if(fail) return SP_NOT_OK; else return SP_OK; }

Datasets:

TempestTeam
/

dataset-the-stack-v2-dedup-sub

The Stack v2 Subset with File Contents (Python, Java, JavaScript, C, C++)

Dataset Summary

Use Cases

How to Use

Dataset Structure

Source Dataset

Curation Rationale

License and Legal Considerations

Citation