text
stringlengths 9
5.83M
|
|---|
/*
* Copyright (C) 2017 spreadtrum.com
*/
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <err.h>
#include <trusty_std.h>
#include <stdio.h>
#include <lib/sprdimgversion/sprdimgversion.h>
#define LOG_TAG "libsprdimgversion"
#define TLOGE(fmt, ...) \
fprintf(stderr, "%s: %d: " fmt, LOG_TAG, __LINE__, ## __VA_ARGS__)
static int sprdimgversion_check_res(struct sprdimgversion_msg *msg, int res)
{
if ((size_t)res < sizeof(*msg)) {
TLOGE("invalid msg length (%zd < %zd)\n", res, sizeof(*msg));
return ERR_NOT_VALID;
}
switch(msg->result) {
case SPRDIMGVERSION_NO_ERROR:
return res - sizeof(*msg);
case SPRDIMGVERSION_ERR_NOT_VALID:
TLOGE("cmd 0x%x: parameter is invalid\n", msg->cmd);
return ERR_NOT_VALID;
case SPRDIMGVERSION_ERR_UNIMPLEMENTED:
TLOGE("cmd 0x%x: is unhandles command\n", msg->cmd);
return ERR_NOT_VALID;
case SPRDIMGVERSION_ERR_GENERIC:
TLOGE("cmd 0x%x: internal server error\n", msg->cmd);
return ERR_GENERIC;
default:
TLOGE("cmd 0x%x: unhandled server response %u\n", msg->cmd, msg->result);
}
return ERR_GENERIC;
}
static ssize_t sprdimgversion_get_res(sprdimgversion_session_t session,
struct iovec *rx_iovs, uint rx_iovcnt)
{
uevent_t ev;
struct ipc_msg_info mi;
struct ipc_msg rx_msg = {
.iov = rx_iovs,
.num_iov = rx_iovcnt,
};
if (!rx_iovcnt)
return 0;
/* wait for reply */
int rc = wait(session, &ev, -1);
if (rc != NO_ERROR) {
TLOGE("%s: interrupted waiting for response", __func__);
return rc;
}
rc = get_msg(session, &mi);
if (rc != NO_ERROR) {
TLOGE("%s: failed to get_msg (%d)\n", __func__, rc);
return rc;
}
rc = read_msg(session, mi.id, 0, &rx_msg);
put_msg(session, mi.id);
if (rc < 0) {
TLOGE("%s: failed to read msg (%d)\n", __func__, rc);
return rc;
}
if ((size_t)rc != mi.len) {
TLOGE("%s: partial message read (%zd vs. %zd)\n",
__func__, (size_t)rc, mi.len);
return ERR_IO;
}
return rc;
}
static int sprdimgversion_wait_to_send(handle_t session, struct ipc_msg *msg)
{
struct uevent ev;
int rc;
rc = wait(session, &ev, -1);
if (rc < 0) {
TLOGE("failed to wait for outgoing queue to free up\n");
return rc;
}
if (ev.event & IPC_HANDLE_POLL_SEND_UNBLOCKED) {
return send_msg(session, msg);
}
if (ev.event & IPC_HANDLE_POLL_MSG) {
return ERR_BUSY;
}
if (ev.event & IPC_HANDLE_POLL_HUP) {
return ERR_CHANNEL_CLOSED;
}
return rc;
}
static ssize_t sprdimgversion_send_req(sprdimgversion_session_t session,
struct iovec *tx_iovs, uint tx_iovcnt,
struct iovec *rx_iovs, uint rx_iovcnt)
{
ssize_t rc;
struct ipc_msg tx_msg = {
.iov = tx_iovs,
.num_iov = tx_iovcnt,
};
rc = send_msg(session, &tx_msg);
if (rc == ERR_NOT_ENOUGH_BUFFER) {
rc = sprdimgversion_wait_to_send(session, &tx_msg);
}
if (rc < 0) {
TLOGE("%s: failed (%d) to send_msg\n", __func__, (int)rc);
return rc;
}
rc = sprdimgversion_get_res(session, rx_iovs, rx_iovcnt);
if (rc < 0) {
TLOGE("%s: failed (%d) to get response\n", __func__, (int)rc);
return rc;
}
return rc;
}
/*
*@session session handle retrieved from sprdimgversion_open
*@imgType The image which need to write the version
*@swVersion return image version
*Return value: zero is ok
*/
int sprd_set_imgversion(sprdimgversion_session_t session, antirb_image_type imgType, unsigned int swVersion)
{
struct sprdimgversion_msg msg = { .cmd = SPRDIMGVERSION_SET};
struct sprdimgversion_get_set_msg req = { .img_type = imgType, .img_version = swVersion };
struct iovec tx[2] = {{&msg, sizeof(msg)}, {&req, sizeof(req)}};
struct iovec rx[1] = {{&msg, sizeof(msg)}};
ssize_t rc = sprdimgversion_send_req(session, tx, 2, rx, 1);
return sprdimgversion_check_res(&msg, rc);
}
/*
*@session session handle retrieved from sprdimgversion_open
*@imgType The image which need to get the version
*@swVersion return image version
*Return value: zero is ok
*
*/
int sprd_get_imgversion(sprdimgversion_session_t session, antirb_image_type imgType, unsigned int* swVersion)
{
struct sprdimgversion_msg msg = { .cmd = SPRDIMGVERSION_GET};
struct sprdimgversion_get_set_msg req = { .img_type = imgType, .img_version = 0 };
struct iovec tx[2] = {{&msg, sizeof(msg)}, {&req, sizeof(req)}};
struct iovec rx[2] = {{&msg, sizeof(msg)}, {&req, sizeof(req)}};
if (swVersion == NULL) {
return ERR_NOT_VALID;
}
ssize_t rc = sprdimgversion_send_req(session, tx, 2, rx, 2);
rc = sprdimgversion_check_res(&msg, rc);
if (rc < 0) { return rc;}
if (rc < (ssize_t)sizeof(req)) {
TLOGE("%s: response lenth error,%d,exp %d\n", __func__, (int)rc, sizeof(req));
return ERR_NOT_VALID;
}
*swVersion = req.img_version;
return 0;
}
/**
* sprdimgversion_open() - Opens a trusty sprdimgversion session.
*
* Return: 0 on success, * or an error code < 0 on
* failure.
*/
int sprdimgversion_open(sprdimgversion_session_t *session)
{
long ret;
ret = connect(SPRDIMGVERSION_CLIENT_PORT, 0);
if (ret < 0) {
return ret;
} else {
*session = ret;
return 0;
}
}
/**
* sprdimgversion_close() - Closes the session.
*/
void sprdimgversion_close(sprdimgversion_session_t session)
{
close(session);
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "commo_header.h"
#include "parse_utili.h"
//
// -1:error 0x00:normal 0x01:constructor
int check_space_type(char *clasn, char *metnm, char *decla, char *space) {
char *toksp = kill_blank(space);
if (!toksp) return -1;
char *tokep = strchr(toksp, ':');
if (!tokep) return -1;
strzcpy(clasn, toksp, tokep - toksp);
//
toksp = strpbrk(++tokep, " (");
if (!toksp) return -1;
strzcpy(metnm, tokep, toksp - tokep);
//
if ('(' != toksp[0x00]) toksp = strchr(toksp + 0x01, '(');
if (!toksp) return -1;
tokep = strchr(tokep, ')');
if (!tokep) return -1;
strzcpy(decla, toksp, tokep - toksp + 0x01);
//
if (strcmp(clasn, metnm)) return 0x00;
return 0x01;
}
char *split_space(char *clasn, char *metnm, char *space) {
char *toksp = kill_blank(space);
if (!toksp) return NULL;
char *tokep = strchr(toksp + 0x01, ':');
if (!tokep) return NULL;
strzcpy(clasn, toksp, tokep - toksp);
strcpy(metnm, tokep + 0x01);
//
return clasn;
}
//
char *split_space_ex(char *clasn, char *metnm, char *space) {
char *toksp = kill_blank(space);
if (!toksp) return NULL;
char *tokep = strchr(toksp + 0x01, ':');
if (!tokep) return NULL;
strzcpy(clasn, toksp, tokep - toksp);
//
toksp = strpbrk(tokep + 0x01, " <");
if (!toksp) return NULL;
strzcpy(metnm, tokep + 0x01, toksp - tokep - 0x01);
//
return toksp;
}
//
char *split_metho_ex(char *clasn, char *metnm, char *decla, char *space) {
char *toksp = kill_blank(space);
if (!toksp) return NULL;
char *tokep = strchr(toksp + 0x01, ':');
if (!tokep) return NULL;
strzcpy(clasn, toksp, tokep - toksp);
//
toksp = strpbrk(tokep + 0x01, " <");
if (!toksp) return NULL;
strzcpy(metnm, tokep + 0x01, toksp - tokep - 0x01);
//
if ('<' != toksp[0x00]) toksp = strchr(toksp + 0x01, '<');
if (!toksp) return NULL;
tokep = strchr(toksp + 0x01, '>');
if (!tokep) return NULL;
strzcpy(decla, toksp, tokep - toksp + 0x01);
//
return tokep + 0x01;
}
//
char *build_retyp_parse(char *retyn, char *parsn, char *handn) {
char *last_str = lccpy(retyn, '_');
last_str = lscpy(last_str, handn);
lscpy(last_str, "_retype_");
//
last_str = lscpy(parsn, "_parse_");
last_str = lscpy(last_str, handn);
lccpy(last_str, '_');
//
return parsn;
}
char *build_obsc_name(char *osize, char *bindn, char *solvn, char *clasn) {
char * last_str = lccpy(osize, '_');
last_str = lscpy(last_str, clasn);
lscpy(last_str, "_size_");
//
last_str = lscpy(bindn, "_bind_");
last_str = lscpy(last_str, clasn);
lccpy(last_str, '_');
//
last_str = lscpy(solvn, "_solve_");
last_str = lscpy(last_str, clasn);
lccpy(last_str, '_');
//
return osize;
}
char *split_metn(char *metnm, char *parsn, char *space) {
char *toke = strchr(space, ':');
if (!toke) return NULL;
strcpy(metnm, toke + 0x01);
char *last_str = lscpy(parsn, "p_");
lscpy(last_str, metnm);
//
return metnm;
}
//
char *split_clame(char *clame, char *space) {
char *toksp = kill_blank(space);
if (!toksp) return NULL;
char *tokep = strpbrk(toksp, " <");
if (!tokep) return NULL;
strzcpy(clame, toksp, tokep - toksp);
return clame;
}
|
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<errno.h>
#include<netinet/in.h>
#include<string.h>
#include<sys/wait.h>
#include<arpa/inet.h>
#include<stdlib.h>
#include<unistd.h>
void sendstring(int sd,char *string);
int main(int argc,char *argv[])
{
int sd,fd;
int con_ret;
struct sockaddr_in serveradd;
sd=socket(AF_INET,SOCK_STREAM,0);
if(sd<0)
{
perror("socket");
exit(1);
}
if(argv[1]==NULL)
{
printf("Please enter server's IP address\n");
exit(0);
}
if(argv[2]==NULL)
{
printf("Please enter server's port\n");
exit(0);
}
if(argv[3]==NULL)
{
printf("Please enter the string to be send to the server\n");
exit(0);
}
memset(&serveradd,0,sizeof(serveradd));
serveradd.sin_family=AF_INET;
serveradd.sin_port=htons(atoi(argv[2]));
serveradd.sin_addr.s_addr=inet_addr(argv[1]);
con_ret=connect(sd,(struct sockaddr*)&serveradd,sizeof(serveradd));
if(con_ret<0)
{
printf("Cannot connect to server\n");
exit(1);
}
sendstring(sd,argv[3]);
return 0;
}
void sendstring(int sd,char *string)
{
int n,byteswritten=0,written;
char buffer[1024];
strcpy(buffer,string);
n=strlen(buffer);
while(byteswritten<n)
{
written=write(sd,buffer+byteswritten,(n-byteswritten));
byteswritten+=written;
}
printf("String %s sent to server\n",buffer);
}
|
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2019-2020 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include <string.h>
#include "py/runtime.h"
#include "py/stream.h"
#include "py/mperrno.h"
#include "extmod/vfs.h"
STATIC void MP_VFS_LFSx(check_open)(MP_OBJ_VFS_LFSx_FILE * self) {
if (self->vfs == NULL) {
mp_raise_ValueError(NULL);
}
}
STATIC void MP_VFS_LFSx(file_print)(const mp_print_t * print, mp_obj_t self_in, mp_print_kind_t kind) {
(void)self_in;
(void)kind;
mp_printf(print, "<io.%s>", mp_obj_get_type_str(self_in));
}
mp_obj_t MP_VFS_LFSx(file_open)(mp_obj_t self_in, mp_obj_t path_in, mp_obj_t mode_in) {
MP_OBJ_VFS_LFSx *self = MP_OBJ_TO_PTR(self_in);
int flags = 0;
const mp_obj_type_t *type = &MP_TYPE_VFS_LFSx_(_textio);
const char *mode_str = mp_obj_str_get_str(mode_in);
for (; *mode_str; ++mode_str) {
int new_flags = 0;
switch (*mode_str) {
case 'r':
new_flags = LFSx_MACRO(_O_RDONLY);
break;
case 'w':
new_flags = LFSx_MACRO(_O_WRONLY) | LFSx_MACRO(_O_CREAT) | LFSx_MACRO(_O_TRUNC);
break;
case 'x':
new_flags = LFSx_MACRO(_O_WRONLY) | LFSx_MACRO(_O_CREAT) | LFSx_MACRO(_O_EXCL);
break;
case 'a':
new_flags = LFSx_MACRO(_O_WRONLY) | LFSx_MACRO(_O_CREAT) | LFSx_MACRO(_O_APPEND);
break;
case '+':
flags |= LFSx_MACRO(_O_RDWR);
break;
#if MICROPY_PY_IO_FILEIO
case 'b':
type = &MP_TYPE_VFS_LFSx_(_fileio);
break;
#endif
case 't':
type = &MP_TYPE_VFS_LFSx_(_textio);
break;
}
if (new_flags) {
if (flags) {
mp_raise_ValueError(NULL);
}
flags = new_flags;
}
}
if (flags == 0) {
flags = LFSx_MACRO(_O_RDONLY);
}
#if LFS_BUILD_VERSION == 1
MP_OBJ_VFS_LFSx_FILE *o = m_new_obj_var_with_finaliser(MP_OBJ_VFS_LFSx_FILE, uint8_t, self->lfs.cfg->prog_size);
#else
MP_OBJ_VFS_LFSx_FILE *o = m_new_obj_var_with_finaliser(MP_OBJ_VFS_LFSx_FILE, uint8_t, self->lfs.cfg->cache_size);
#endif
o->base.type = type;
o->vfs = self;
#if !MICROPY_GC_CONSERVATIVE_CLEAR
memset(&o->file, 0, sizeof(o->file));
memset(&o->cfg, 0, sizeof(o->cfg));
#endif
o->cfg.buffer = &o->file_buffer[0];
#if LFS_BUILD_VERSION == 2
if (self->enable_mtime) {
lfs_get_mtime(&o->mtime[0]);
o->attrs[0].type = LFS_ATTR_MTIME;
o->attrs[0].buffer = &o->mtime[0];
o->attrs[0].size = sizeof(o->mtime);
o->cfg.attrs = &o->attrs[0];
o->cfg.attr_count = MP_ARRAY_SIZE(o->attrs);
}
#endif
const char *path = MP_VFS_LFSx(make_path)(self, path_in);
int ret = LFSx_API(file_opencfg)(&self->lfs, &o->file, path, flags, &o->cfg);
if (ret < 0) {
o->vfs = NULL;
mp_raise_OSError(-ret);
}
return MP_OBJ_FROM_PTR(o);
}
STATIC mp_obj_t MP_VFS_LFSx(file___exit__)(size_t n_args, const mp_obj_t *args) {
(void)n_args;
return mp_stream_close(args[0]);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(MP_VFS_LFSx(file___exit___obj), 4, 4, MP_VFS_LFSx(file___exit__));
STATIC mp_uint_t MP_VFS_LFSx(file_read)(mp_obj_t self_in, void *buf, mp_uint_t size, int *errcode) {
MP_OBJ_VFS_LFSx_FILE *self = MP_OBJ_TO_PTR(self_in);
MP_VFS_LFSx(check_open)(self);
LFSx_API(ssize_t) sz = LFSx_API(file_read)(&self->vfs->lfs, &self->file, buf, size);
if (sz < 0) {
*errcode = -sz;
return MP_STREAM_ERROR;
}
return sz;
}
STATIC mp_uint_t MP_VFS_LFSx(file_write)(mp_obj_t self_in, const void *buf, mp_uint_t size, int *errcode) {
MP_OBJ_VFS_LFSx_FILE *self = MP_OBJ_TO_PTR(self_in);
MP_VFS_LFSx(check_open)(self);
#if LFS_BUILD_VERSION == 2
if (self->vfs->enable_mtime) {
lfs_get_mtime(&self->mtime[0]);
}
#endif
LFSx_API(ssize_t) sz = LFSx_API(file_write)(&self->vfs->lfs, &self->file, buf, size);
if (sz < 0) {
*errcode = -sz;
return MP_STREAM_ERROR;
}
return sz;
}
STATIC mp_uint_t MP_VFS_LFSx(file_ioctl)(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
MP_OBJ_VFS_LFSx_FILE *self = MP_OBJ_TO_PTR(self_in);
if (request != MP_STREAM_CLOSE) {
MP_VFS_LFSx(check_open)(self);
}
if (request == MP_STREAM_SEEK) {
struct mp_stream_seek_t *s = (struct mp_stream_seek_t *)(uintptr_t)arg;
int res = LFSx_API(file_seek)(&self->vfs->lfs, &self->file, s->offset, s->whence);
if (res < 0) {
*errcode = -res;
return MP_STREAM_ERROR;
}
res = LFSx_API(file_tell)(&self->vfs->lfs, &self->file);
if (res < 0) {
*errcode = -res;
return MP_STREAM_ERROR;
}
s->offset = res;
return 0;
} else if (request == MP_STREAM_FLUSH) {
int res = LFSx_API(file_sync)(&self->vfs->lfs, &self->file);
if (res < 0) {
*errcode = -res;
return MP_STREAM_ERROR;
}
return 0;
} else if (request == MP_STREAM_CLOSE) {
if (self->vfs == NULL) {
return 0;
}
int res = LFSx_API(file_close)(&self->vfs->lfs, &self->file);
self->vfs = NULL; // indicate a closed file
if (res < 0) {
*errcode = -res;
return MP_STREAM_ERROR;
}
return 0;
} else {
*errcode = MP_EINVAL;
return MP_STREAM_ERROR;
}
}
STATIC const mp_rom_map_elem_t MP_VFS_LFSx(file_locals_dict_table)[] = {
{ MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
{ MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
{ MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
{ MP_ROM_QSTR(MP_QSTR_readlines), MP_ROM_PTR(&mp_stream_unbuffered_readlines_obj) },
{ MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
{ MP_ROM_QSTR(MP_QSTR_flush), MP_ROM_PTR(&mp_stream_flush_obj) },
{ MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
{ MP_ROM_QSTR(MP_QSTR_seek), MP_ROM_PTR(&mp_stream_seek_obj) },
{ MP_ROM_QSTR(MP_QSTR_tell), MP_ROM_PTR(&mp_stream_tell_obj) },
{ MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&mp_stream_close_obj) },
{ MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&mp_identity_obj) },
{ MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&MP_VFS_LFSx(file___exit___obj)) },
};
STATIC MP_DEFINE_CONST_DICT(MP_VFS_LFSx(file_locals_dict), MP_VFS_LFSx(file_locals_dict_table));
#if MICROPY_PY_IO_FILEIO
STATIC const mp_stream_p_t MP_VFS_LFSx(fileio_stream_p) = {
MP_PROTO_IMPLEMENT(MP_QSTR_protocol_stream)
.read = MP_VFS_LFSx(file_read),
.write = MP_VFS_LFSx(file_write),
.ioctl = MP_VFS_LFSx(file_ioctl),
};
const mp_obj_type_t MP_TYPE_VFS_LFSx_(_fileio) = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_EXTENDED,
.name = MP_QSTR_FileIO,
.print = MP_VFS_LFSx(file_print),
.locals_dict = (mp_obj_dict_t *)&MP_VFS_LFSx(file_locals_dict),
MP_TYPE_EXTENDED_FIELDS(
.getiter = mp_identity_getiter,
.iternext = mp_stream_unbuffered_iter,
.protocol = &MP_VFS_LFSx(fileio_stream_p),
),
};
#endif
STATIC const mp_stream_p_t MP_VFS_LFSx(textio_stream_p) = {
MP_PROTO_IMPLEMENT(MP_QSTR_protocol_stream)
.read = MP_VFS_LFSx(file_read),
.write = MP_VFS_LFSx(file_write),
.ioctl = MP_VFS_LFSx(file_ioctl),
.is_text = true,
};
const mp_obj_type_t MP_TYPE_VFS_LFSx_(_textio) = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_EXTENDED,
.name = MP_QSTR_TextIOWrapper,
.print = MP_VFS_LFSx(file_print),
.locals_dict = (mp_obj_dict_t *)&MP_VFS_LFSx(file_locals_dict),
MP_TYPE_EXTENDED_FIELDS(
.getiter = mp_identity_getiter,
.iternext = mp_stream_unbuffered_iter,
.protocol = &MP_VFS_LFSx(textio_stream_p),
),
};
|
#ifndef INDIVIDUO_H
#define INDIVIDUO_H
void inserirIndividuo();
int buscarIndividuo(char *id);
void removerIndividuo();
#endif
|
/**
* 5. Crie um programa que defina e imprima a seguinte matriz:
*
* {
* { 'I', 'F', 'S', 'P' },
* { '2', '0', '1', '6' }
* }
*/
#include<stdio.h>
int main()
{
int i, j;
char matriz[2][4] =
{
{ 'I', 'F', 'S', 'P' },
{ '2', '0', '1', '6' }
};
for(i = 0; i < 2; i++)
{
for(j = 0; j < 4; j++)
{
printf("%c", matriz[i][j]);
}
printf("\n");
}
getchar();
return 0;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <omp.h>
#include <complex.h>
#define spIndType long long
#define spValType float complex
void applyHybridKaczmarz(spIndType *rowptr , spValType *valA ,spIndType *colA, long long numDomains, long long domainLength ,
unsigned int *ArrIdxs, spValType *x, spValType *b, spValType *invD,long long numit, long long numCores){
omp_set_num_threads(numCores);
#pragma omp parallel shared(x,b,rowptr,valA,colA,invD,numit,ArrIdxs)
{
int domain;
unsigned int row;
spIndType k,i,gIdx;
double complex inner;
for (k=0 ; k < numit ; ++k){
#pragma omp for
for (domain=0 ; domain < numDomains ; ++domain){
for (i=0 ; i < domainLength ; ++i){
row = ArrIdxs[domain*domainLength + i];
if (row > 0){
inner = b[row-1];
for (gIdx = rowptr[row-1]-1; gIdx < rowptr[row]-1; ++gIdx){
// gIdx is in C indices here...
inner -= conj(valA[gIdx])*x[colA[gIdx]-1];
}
inner*=invD[row-1];
for (gIdx = rowptr[row-1]-1; gIdx < rowptr[row]-1; ++gIdx){
// gIdx is in C indices here...
x[colA[gIdx]-1] += inner*valA[gIdx];
}
}
}
}
}
}
return;
}
|
#include <stdio.h>
int main()
{
float num1, num2, result;
char op;
printf("Enter your operation\n");
scanf("%f %c %f", &num1, &op, &num2);
switch (op)
{
case '-':
result = num1 - num2;
printf("Result: %.2f", result);
break;
case '+':
result = num1 + num2;
printf("Result: %.2f", result);
break;
case '*':
result = num1 * num2;
printf("Result: %.2f", result);
break;
case '/':
result = num1 / num2;
printf("Result: %.2f", result);
break;
default:
printf("The operation is not valid");
break;
}
return 0;
}
|
#include <stdio.h>
void welcome(void)
{
printf("---=== Grocery Inventory System ===---\n\n");
}
void prnTitle(void)
{
printf("Row |SKU| Name | Price |Taxed| Qty | Min | Total |Atn\n");
printf("----+---+--------------------+--------+-----+-----+-----+------------|---\n");
}
void prnFooter(double gTotal)
{
printf("--------------------------------------------------------+----------------\n");
if(gTotal > 0)
printf(" Grand Total: |%12.2lf\n",gTotal);
}
void clrKyb(void)
{
char character;
do {
scanf("%c",&character);
}
while(character != '\n');
}
void pause(void)
{
printf("Press <ENTER> to continue...");
clrKyb();
}
int getInt(void)
{
char NL = 'x';
int value;
while (NL != '\n')
{
scanf("%d%c",&value,&NL);
if (NL != '\n')
{
clrKyb();
printf("Invalid integer, please try again: ");
}
}
return value;
}
double getDbl(void)
{
char NL = 'x';
double value;
while (NL != '\n')
{
scanf("%lf%c",&value,&NL);
if (NL != '\n')
{
clrKyb();
printf("Invalid number, please try again: ");
}
}
return value;
}
int getIntLimited(int lowerLimit, int upperLimit)
{
int value;
do {
value = getInt();
if (value < lowerLimit || value > upperLimit)
{
printf("Invalid value, %d < value < %d: ",lowerLimit,upperLimit);
}
}
while (value < lowerLimit || value >upperLimit);
return value;
}
double getDblLimited(double lowerLimit, double upperLimit)
{
double value;
do {
value = getDbl();
if (value < lowerLimit || value > upperLimit)
{
printf("Invalid value, %lf< value < %lf: ",lowerLimit,upperLimit);
}
}
while (value < lowerLimit || value > upperLimit);
return value;
}
int main(void) {
int iVal;
double dVal;
welcome(); //welcome message
printf("listing header and footer with grand total:\n");
prnTitle(); //print title
prnFooter(1234.5678); //print footer
printf("listing header and footer without grand total:\n");
prnTitle(); //print title
prnFooter(-1); //print footer
pause(); //waiting for <Enter>
printf("Enter an integer: ");
iVal = getInt(); //get Integer
printf("You entered: %d\n", iVal);
printf("Enter an integer between 10 and 20: ");
iVal = getIntLimited(10, 20); //get integer from range
printf("Your entered %d\n", iVal);
printf("Enter a floating point number: ");
dVal = getDbl(); //get floating point number
printf("You entered: %0.2lf\n", dVal);
printf("Enter a floating point number between 10.00 and 20.00: ");
dVal = getDblLimited(10.0, 20.0); //get floating point number from range
printf("You entered: %0.2lf\n", dVal);
printf("End of tester program for milestone one!\n");
return 0;
}
|
#include "min_unit.h"
#include "common.h"
#include "tests_common.h"
#include <stdlib.h>
#include <stdio.h>
#ifdef _WIN32
#include <process.h>
#endif
char* test_cell_type_is_player_owned()
{
mu_assert(!cell_type_is_player_owned(GROUND));
mu_assert(!cell_type_is_player_owned(WATER));
mu_assert(!cell_type_is_player_owned(ROCK));
mu_assert(cell_type_is_player_owned(HEADQUARTER));
mu_assert(!cell_type_is_player_owned(BRIDGE));
mu_assert(cell_type_is_player_owned(UNIT_1));
mu_assert(cell_type_is_player_owned(UNIT_2));
mu_assert(cell_type_is_player_owned(UNIT_3));
return 0;
}
char* test_cell_type_is_unit() {
mu_assert(!cell_type_is_unit(GROUND));
mu_assert(!cell_type_is_unit(WATER));
mu_assert(!cell_type_is_unit(ROCK));
mu_assert(!cell_type_is_unit(HEADQUARTER));
mu_assert(!cell_type_is_unit(BRIDGE));
mu_assert(cell_type_is_unit(UNIT_1));
mu_assert(cell_type_is_unit(UNIT_2));
mu_assert(cell_type_is_unit(UNIT_3));
return 0;
}
char* test_pos_init() {
int i, j;
for (i = 0; i <= 10; i++) {
for (j = 0; j <= 10; j++) {
/*printf("\n%d,%d", i, j);*/
Pos pos = pos_init(i, j);
/*test niet per se nodig*/
//mu_assert(pos.row == i && pos.col == j);
mu_assert((&pos) != NULL);
}
}
return 0;
}
char* test_path_alloc() {
unsigned int i, j;
for (i = 0; i < 10; i++) {
for (j = 0; j < 10; j++) {
Path* path = path_alloc(i, j);
/*test niet per se nodig*/
//mu_assert(path->step_count == i && path->distance == j && (&(path->steps)) != NULL);
mu_assert(path != NULL);
}
}
return 0;
}
char* test_path_free() {
Path* path = path_alloc(1, 1);
path_free(&path);
mu_assert(path == NULL);
return 0;
}
|
/*
* TestLCD.c
*
* Created: 11/14/2014 12:07:54 PM
* Author: saida
*/
/*
* LCD_Atmel1.c
*
* Created: 10/24/2014 3:29:51 PM
* Author: LuisDavid
* still a alpha Version 0.2
*/
// CARLOS:
// FROM LCD_Atmel.h you there is a line you can modify at will
// to change how the cursor looks like
#define F_CPU 8000000UL // 1MHz internal clock speed of ATmega328
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <util/twi.h>
#include "TWI_Master.h"
#include "TestLCD_H.h"
void LCD_LONG_MEM_WRITE();
void init_lcd();
void LCD_SINGLE_MEM_WRITE (unsigned char BYTE);
int main(void)
{
unsigned char single[1];
//all steps to initialize and timings
init_lcd();
// store and send one char at the time using Display single
single[0] = 'L';
Display_Single(single);
single[0] = 'U';
Display_Single(single);
single[0] = 'I';
Display_Single(single);
single[0] = 'S';
Display_Single(single);
single[0] = 'A';
Display_Single(single);
single[0] = 'N';
Display_Single(single);
single[0] = 'D';
Display_Single(single);
_delay_ms(500);
// changes the cursor address to the second line
// no need to fill the line
Second_Line();
// same sequence as above one char at a time
single[0] = 'R';
Display_Single(single);
single[0] = 'Y';
Display_Single(single);
single[0] = 'A';
Display_Single(single);
single[0] = 'N';
Display_Single(single);
single[0] = '!';
Display_Single(single);
_delay_ms(1000);
// Clear and bring cursor to 0,0
Clear_Screen();
// Display message
Display_Home_Msg ();
_delay_ms(2000);
Display_Up_Arrow_Wr ();
_delay_ms(2000);
Display_Down_Arrow_Wr ();
// _delay_ms(1000);
// only to know I was done Ignore
while(1)
{
PORTB |= (1<<PORTB1); //turn blue LED on to signify we are in at home screen
_delay_ms(500);
PORTB &= ~(1<<PORTB1); //turn red LED off
_delay_ms(500);
}
return 0;
}
|
#include <stdio.h>
typedef struct _var {
int v, n;
} var;
// функция подсчёта повторений
var* cnt_moda(const int* f, const int* l, var* v) {
var* p, * n;
for (n = v; f != l; ++f) {
for (p = v; (p != n) && (p->v != *f); ++p);
p->v = *f;
p->n++;
if (p >= n)
++n;
}
return v + (n - v);
}
// функция возвращает максимум повторений
int max_moda(const var* f, const var* l) {
int m = f->n;
while (f != l) {
if (f->n > m)
m = f->n;
++f;
}
return m;
}
int main(void)
{
int mas[] = { 8872, 10044, 7590, 6068, 6086, 5840, 5768, 5738, 5826, 5654, 5376, 5698, 5726, 5630, 5618, 5668, 5444, 5686, 5670, 5434, 5478, 5514, 5442, 5676, 5664, 5592, 5708, 5700, 5660, 5500, 5746, 5416, 5676, 5726, 5578, 5654, 5608, 5662, 5720, 9180 };
int cnt, i = 0;
float aver = 0;
var vs[40] = { 0 };
var* it, * end;
end = cnt_moda(mas, mas + sizeof(mas) / sizeof(mas[0]), vs);
cnt = max_moda(vs, end);
for (it = vs; it != end; ++it) {
if (it->n == cnt)
{
printf("moda: %d\n", it->v);
aver += it->v;
i++;
}
}
aver /= i;
printf("%f", aver);
return 0;
}
|
#include <std.h>
#include <marsh.h>
inherit MONSTER;
void create() {
::create();
set_gender("female");
set_name("fish");
set_id( ({ "rainbow","rainbow trout","fish"}) );
set_short("A rainbow trout");
set_long("The colors of the rainbow are brightly displayed on the side of this fish.");
set_level(20);
set_body_type("fish");
set_alignment(10);
set_race("fish");
set_class("fighter");
}
|
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <fcntl.h>
#include <ctype.h>
#include <termios.h>
#include <sys/types.h>
#include <sys/mman.h>
#include "ocelot.h"
#define FATAL do { fprintf(stderr, "Error at line %d, file %s (%d) [%s]\n", \
__LINE__, __FILE__, errno, strerror(errno)); exit(1); } while(0)
#define MAP_SIZE 4096UL
#define MAP_MASK (MAP_SIZE - 1)
typedef enum {
SYMREG_COMPONENTS_TGT,
SYMREG_COMPONENTS_GRP,
SYMREG_COMPONENTS_REG,
SYMREG_COMPONENTS_LAST
} symreg_components_t;
typedef enum {
SYMREG_QUERY_SZ,
SYMREG_QUERY_QUERY,
SYMREG_QUERY_READ,
SYMREG_QUERY_LAST
} symreg_query_t;
int fd = -1;
unsigned long phys;
void *map_base;
static unsigned long read_reg(unsigned long addr) {
if (fd < 0)
if((fd = open("/dev/mem", O_RDWR | O_SYNC)) == -1) FATAL;
if (addr < phys || addr >= (phys + MAP_SIZE)) {
if (phys)
if(munmap(map_base, MAP_SIZE) == -1) FATAL;
} else {
return *((unsigned long *) (map_base + addr - phys));
}
fflush(stdout);
phys = addr & ~MAP_MASK;
map_base = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, phys);
if(map_base == (void *) -1) FATAL;
return *((unsigned long *) (map_base + addr - phys));
}
struct component_info {
int idx;
int repl;
};
static int find_target(struct component_info *info, char *pattern)
{
int t;
for (t = 0; vtss_symreg_targets[t].name; t++) {
int repl = info[SYMREG_COMPONENTS_TGT].repl;
if (repl >=0 && repl != vtss_symreg_targets[t].repl_number)
continue;
if (!strcmp(pattern, vtss_symreg_targets[t].name))
break;
}
if (!vtss_symreg_targets[t].name)
return -1;
info[SYMREG_COMPONENTS_TGT].idx = t;
return 0;
}
static int find_grp(struct component_info *info, char *pattern)
{
int t = info[SYMREG_COMPONENTS_TGT].idx;
const vtss_symreg_reggrp_t *groups;
int g;
groups = vtss_symreg_targets[t].reggrps;
for (g = 0; groups[g].name; g++) {
if (!strcmp(pattern, groups[g].name))
break;
}
if (!groups[g].name)
return -1;
info[SYMREG_COMPONENTS_GRP].idx = g;
return 0;
}
static int find_reg(struct component_info *info, char *pattern)
{
int t = info[SYMREG_COMPONENTS_TGT].idx;
int g = info[SYMREG_COMPONENTS_GRP].idx;
int r;
const vtss_symreg_target_t *tgt = &vtss_symreg_targets[t];
const vtss_symreg_reggrp_t *grp = &tgt->reggrps[g];
const vtss_symreg_reg_t *regs = grp->regs;
for (r = 0; regs[r].name; r++) {
if (!strcmp(pattern, regs[r].name))
break;
}
if (!regs[r].name)
return -1;
info[SYMREG_COMPONENTS_REG].idx = r;
return 0;
}
static int find_component(struct component_info *info, int i, char *pattern)
{
switch (i) {
case SYMREG_COMPONENTS_TGT:
return find_target(info, pattern);
break;
case SYMREG_COMPONENTS_GRP:
return find_grp(info, pattern);
break;
case SYMREG_COMPONENTS_REG:
return find_reg(info, pattern);
break;
}
return -1;
}
static int match_regs(char *pattern, struct component_info *info)
{
int i;
char *str1 = pattern, *str2;
size_t cnt;
for (i = 0; i < SYMREG_COMPONENTS_LAST; i++) {
info[i].idx = -1;
info[i].repl = -1;
}
for (i = 0; i < SYMREG_COMPONENTS_LAST; i++) {
if (str1 == NULL) {
break;
}
str2 = strstr(str1, ":");
if (str2) {
if (i == SYMREG_COMPONENTS_REG)
return -1;
cnt = str2 - str1;
} else {
cnt = strlen(str1);
}
if (str2)
*str2 = '\0';
if (cnt > 0) {
if (str1[cnt-1] == ']') {
char *b_end = &str1[cnt - 1];
char *b_start = b_end;
while (b_start > str1) {
if (*b_start == '[')
break;
b_start--;
}
if (b_start == str1)
return -1;
*b_start++ = '\0';
*b_end = '\0';
info[i].repl = strtoul(b_start, NULL, 10);
}
if (find_component(info, i, str1))
return -1;
}
if (str2)
str1 = str2 + 1;
else
str1 = NULL;
}
return 0;
}
static void print_regr(struct component_info *info, int *max_width, int query)
{
int t = info[SYMREG_COMPONENTS_TGT].idx;
int g = info[SYMREG_COMPONENTS_GRP].idx;
int gr = info[SYMREG_COMPONENTS_GRP].repl;
int r = info[SYMREG_COMPONENTS_REG].idx;
int rr = info[SYMREG_COMPONENTS_REG].repl;
const vtss_symreg_target_t *tgt = &vtss_symreg_targets[t];
const vtss_symreg_reggrp_t *grp = &tgt->reggrps[g];
const vtss_symreg_reg_t *reg = &grp->regs[r];
unsigned int addr;
char name[256];
char grptmp[50];
const char *grpname = grptmp;
char tgttmp[50];
const char *tgtname = tgttmp;
if (grp->repl_cnt > 1)
snprintf(grptmp, sizeof(grptmp), "%s[%u]", grp->name, gr);
else
grpname = grp->name;
if (tgt->repl_number >= 0)
snprintf(tgttmp, sizeof(tgttmp), "%s[%u]", tgt->name, tgt->repl_number);
else
tgtname = tgt->name;
addr = tgt->base_addr + (grp->base_addr << 2) + gr * 4 * grp->repl_width + (reg->addr + rr) * 4;
if (reg->repl_cnt > 1)
snprintf(name, sizeof(name), "%s:%s:%s[%u]", tgtname, grpname, reg->name, rr);
else
snprintf(name, sizeof(name), "%s:%s:%s", tgtname, grpname, reg->name);
if (query == SYMREG_QUERY_SZ) {
int len = strlen(name);
if (len > *max_width)
*max_width = len;
return;
}
if (query == SYMREG_QUERY_QUERY)
printf("%-*s 0x%08x\n", *max_width, name, addr);
else {
unsigned int v = read_reg(addr);
int j;
printf("%-*s 0x%08x %10u ", *max_width, name, v, v);
for (j = 31; j >= 0; j--) {
printf("%d%s", v & (1 << j) ? 1 : 0, j == 0 ? "\n" : (j % 4) ? "" : ".");
}
}
}
static int print_reg(struct component_info *info, int *max_width, int query)
{
int t = info[SYMREG_COMPONENTS_TGT].idx;
int g = info[SYMREG_COMPONENTS_GRP].idx;
int r = info[SYMREG_COMPONENTS_REG].idx;
const vtss_symreg_target_t *tgt = &vtss_symreg_targets[t];
const vtss_symreg_reggrp_t *grp = &tgt->reggrps[g];
const vtss_symreg_reg_t *reg = &grp->regs[r];
int repl = info[SYMREG_COMPONENTS_REG].repl;
int rp;
if (repl < 0) {
for (rp = 0; rp < reg->repl_cnt; rp++) {
info[SYMREG_COMPONENTS_REG].repl = rp;
print_regr(info, max_width, query);
}
info[SYMREG_COMPONENTS_REG].repl = -1;
} else {
print_regr(info, max_width, query);
}
return 0;
}
static int print_grpr(struct component_info *info, int *max_width, int query)
{
int t = info[SYMREG_COMPONENTS_TGT].idx;
int g = info[SYMREG_COMPONENTS_GRP].idx;
const vtss_symreg_target_t *tgt = &vtss_symreg_targets[t];
const vtss_symreg_reggrp_t *grp = &tgt->reggrps[g];
const vtss_symreg_reg_t *regs = grp->regs;
if (info[SYMREG_COMPONENTS_REG].idx < 0) {
int r;
for (r = 0; regs[r].name; r++) {
info[SYMREG_COMPONENTS_REG].idx = r;
info[SYMREG_COMPONENTS_REG].repl = -1;
print_reg(info, max_width, query);
}
info[SYMREG_COMPONENTS_REG].idx = -1;
} else {
print_reg(info, max_width, query);
}
return 0;
}
static int print_grp(struct component_info *info, int *max_width, int query)
{
int t = info[SYMREG_COMPONENTS_TGT].idx;
int g = info[SYMREG_COMPONENTS_GRP].idx;
const vtss_symreg_target_t *tgt = &vtss_symreg_targets[t];
const vtss_symreg_reggrp_t *grp = &tgt->reggrps[g];
int repl = info[SYMREG_COMPONENTS_GRP].repl;
int rp;
if (repl < 0) {
for (rp = 0; rp < grp->repl_cnt; rp++) {
info[SYMREG_COMPONENTS_GRP].repl = rp;
print_grpr(info, max_width, query);
}
info[SYMREG_COMPONENTS_GRP].repl = -1;
} else {
print_grpr(info, max_width, query);
}
return 0;
}
static int print_target(struct component_info *info, int *max_width, int query)
{
const vtss_symreg_reggrp_t *groups;
int t, g;
t = info[SYMREG_COMPONENTS_TGT].idx;
groups = vtss_symreg_targets[t].reggrps;
if (info[SYMREG_COMPONENTS_GRP].idx < 0) {
for (g = 0; groups[g].name; g++) {
info[SYMREG_COMPONENTS_GRP].idx = g;
info[SYMREG_COMPONENTS_GRP].repl = -1;
print_grp(info, max_width, query);
}
info[SYMREG_COMPONENTS_GRP].idx = -1;
} else {
print_grp(info, max_width, query);
}
return 0;
}
static int print_targets(struct component_info *info, int *max_width, int query)
{
int tgt;
if (query == SYMREG_QUERY_QUERY)
printf("%-*s %-10s\n", *max_width, "Register", "Address");
else if (query == SYMREG_QUERY_READ)
printf("%-*s %-10s %-10s 31 24 23 16 15 8 7 0\n", *max_width, "Register", "Value", "Decimal");
tgt = info[SYMREG_COMPONENTS_TGT].idx;
if (info[SYMREG_COMPONENTS_TGT].repl < 0) {
int t;
for (t = tgt; !strcmp(vtss_symreg_targets[t].name, vtss_symreg_targets[tgt].name) ; t++) {
info[SYMREG_COMPONENTS_TGT].idx = t;
print_target(info, max_width, query);
}
info[SYMREG_COMPONENTS_TGT].idx = tgt;
} else {
print_target(info, max_width, query);
}
return 0;
}
int main(int argc, char **argv) {
int query = SYMREG_QUERY_QUERY;
struct component_info info[SYMREG_COMPONENTS_LAST];
int max_width = 0;
if(argc < 3) {
fprintf(stderr, "\nUsage:\t%s <read|query> <target>\n"
"\ttarget : name of the target to dump\n",
argv[0]);
exit(1);
}
if (!strcmp(argv[1], "read"))
query = SYMREG_QUERY_READ;
if (match_regs(argv[2], info))
exit(1);
print_targets(info, &max_width, SYMREG_QUERY_SZ);
print_targets(info, &max_width, query);
close(fd);
return 0;
}
|
/*--------------------------------------------------------------------------*/
/* */
/* comp2.c */
/* 23/04/2021 */
/* */
/* This is a full compiler performing syntax and semantic error */
/* detection and code generation for the CPL language, including */
/* procedure definitions. */
/* */
/* Authors: Ronan Keaveney, Charlie Gorey O'Neill, */
/* Conor Cosgrave, Emmett Lawlor */
/* */
/* */
/*--------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "global.h"
#include "scanner.h"
#include "line.h"
#include "code.h"
#include "debug.h"
#include "sets.h"
#include "strtab.h"
#include "symbol.h"
/*--------------------------------------------------------------------------*/
/* */
/* Global variables used by this parser. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE FILE *InputFile; /* CPL source comes from here. */
PRIVATE FILE *ListFile; /* For nicely-formatted syntax errors. */
PRIVATE FILE *CodeFile; /* machine code output file */
PRIVATE TOKEN CurrentToken; /* Parser lookahead token. Updated by */
/* routine Accept (below). Must be */
/* initialised before parser starts. */
PRIVATE int Read;
PRIVATE int scope;
PRIVATE int Write;
PRIVATE int VarLctn;
PRIVATE int FlagError;
/*---------------------------------------------------------------------------
Declare Sets
----------------------------------------------------------------------------*/
PRIVATE SET StatementFS_aug, StatementFBS, ProgProcDecSet1, ProgProcDecSet2;
PRIVATE SET BlockSet1;
PRIVATE SET FB_Prog, FB_ProcDec, FB_Block;
PRIVATE SET StatementFS_aug2, StatementFBS2;
/*--------------------------------------------------------------------------*/
/* */
/* Function prototypes */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseProgram( void );
PRIVATE int ParseDeclarations( void );
PRIVATE void ParseProcDeclaration( void );
PRIVATE void ParseParameterList( void );
PRIVATE void ParseFormalParameter( void );
PRIVATE void ParseBlock( void );
PRIVATE void ParseStatement( void );
PRIVATE void ParseSimpleStatement( void );
PRIVATE void ParseRestOfStatement( SYMBOL *target );
PRIVATE void ParseProcCallList( void );
PRIVATE void ParseAssignment( void );
PRIVATE void ParseActualParameter( void );
PRIVATE void ParseWhileStatement( void );
PRIVATE void ParseIfStatement( void );
PRIVATE void ParseReadStatement( void );
PRIVATE void ParseWriteStatement( void );
PRIVATE void ParseExpression( void );
PRIVATE void ParseCompoundTerm( void );
PRIVATE void ParseTerm( void );
PRIVATE void ParseSubTerm( void );
PRIVATE void ParseAddOp( void );
PRIVATE void ParseMultOp( void );
PRIVATE void SetupSets( void );
PRIVATE void Synchronise( SET *F, SET*FB );
PRIVATE void Accept( int code );
PRIVATE void ReadToEndOfFile( void );
PRIVATE void ParseIntConst(void);
PRIVATE void ParseIdentifier(void);
PRIVATE void ParseVariable(void);
PRIVATE int ParseBooleanExpression( void );
PRIVATE int ParseRelOp( void );
PRIVATE int OpenFiles( int argc, char *argv[] );
PRIVATE void MakeSymbolTableEntry(int symtype);
PRIVATE SYMBOL *LookupSymbol();
/*--------------------------------------------------------------------------*/
/* */
/* Main: Smallparser entry point. Sets up parser globals (opens input and */
/* output files, initialises current lookahead), then calls */
/* "ParseProgram" to start the parse. */
/* */
/*--------------------------------------------------------------------------*/
PUBLIC int main ( int argc, char *argv[] )
{
Write=0;
Read = 0;
scope = 1;
FlagError=0;
VarLctn = 0;
if ( OpenFiles( argc, argv ) )
{
InitCharProcessor( InputFile, ListFile );
InitCodeGenerator(CodeFile); /*Initialize code generation*/
CurrentToken = GetToken();
SetupSets();
ParseProgram();
WriteCodeFile(); /*Write out assembly to file*/
fclose( InputFile );
fclose( ListFile );
if(FlagError)
{
printf("Syntax Error Detected\n");
return EXIT_FAILURE;
}
printf("Valid, No Errors Detected\n");
return EXIT_SUCCESS;
}
else
{
printf("Syntax Error Dectected\n");
return EXIT_FAILURE;
}
}
/*--------------------------------------------------------------------------*/
/* */
/* SetupSets: This function serves the purpose of initializing all */
/* the sets used for the Primary Augmented S-Algol Error recovery */
/* and resync */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void SetupSets(void){
InitSet(&StatementFS_aug, 6, IDENTIFIER, WHILE, IF, READ, WRITE, END );
InitSet(&StatementFBS, 4, SEMICOLON, ELSE, ENDOFPROGRAM, ENDOFINPUT );
InitSet(&ProgProcDecSet1, 3, VAR, PROCEDURE, BEGIN );
InitSet(&ProgProcDecSet2, 2, PROCEDURE, BEGIN );
InitSet(&BlockSet1, 6, IDENTIFIER, WHILE, IF, READ, WRITE, END);
InitSet(&FB_Prog, 3, ENDOFPROGRAM, ENDOFINPUT, END);
InitSet(&FB_ProcDec, 3, ENDOFPROGRAM, ENDOFINPUT, END);
InitSet(&FB_Block, 4, ENDOFINPUT, ELSE, SEMICOLON, ENDOFPROGRAM );
InitSet(&StatementFS_aug2, 6, IDENTIFIER, WHILE, IF, READ, WRITE, END );
InitSet(&StatementFBS2, 4, SEMICOLON, ELSE, ENDOFPROGRAM, ENDOFINPUT );
}
/*--------------------------------------------------------------------------*/
/* */
/* Synchronise Function: Once the parser encounters a syntax error */
/* this will skip over the error and resync, allowing the parser to */
/* continue parsing the program */
/* */
/* Inputs: F = Augmented First Set */
/* FB = Follow Set union Beacons Set */
/* */
/* Outputs: S = F union FB */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void Synchronise(SET *F, SET *FB){
SET S;
S = Union( 2, F, FB );
if( !InSet( F, CurrentToken.code ) )
{
SyntaxError2( *F, CurrentToken );
while( !InSet( &S, CurrentToken.code ) )
CurrentToken = GetToken();
}
}
/*--------------------------------------------------------------------------*/
/* */
/* Parser routines: Recursive-descent implementaion of the grammar's */
/* productions. */
/* */
/* */
/* ParseProgram implements: */
/* */
/* <Program> :== "PROGRAM" <Identifier> ";" */
/* [ <Declarations> ] {<ProcDeclaration>} */
/* <Block> "." */
/* */
/* Sync Points before [<Declarations>] */
/* before and immediatley after [<ProcDeclarations>] */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseProgram(void)
{
Accept(PROGRAM);
Accept(IDENTIFIER);
Accept(SEMICOLON);
MakeSymbolTableEntry(STYPE_PROGRAM);
/* Synchronise ParseProgramSet1, Followers, Beacons */
Synchronise( &ProgProcDecSet1, &FB_Prog );
if ( CurrentToken.code == VAR ) ParseDeclarations();
/* Synchronise ParseProgramSet2, Followers, Beacons */
Synchronise( &ProgProcDecSet2, &FB_Prog );
/* Recursive ProcDeclaration */
while (CurrentToken.code == PROCEDURE )
{
ParseProcDeclaration();
/* Synchronise ParseProgramSet2, Followers, Beacons */
Synchronise( &ProgProcDecSet2, &FB_Prog );
}
ParseBlock();
Accept( ENDOFPROGRAM );
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseDeclararions implements: */
/* */
/* <Declarations> :== "VAR" <Variable> { "," <Variable> } ";" */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE int ParseDeclarations(void)
{
int VarCounter = 0;
Accept( VAR );
MakeSymbolTableEntry(STYPE_VARIABLE);
Accept( IDENTIFIER );
ParseVariable();
VarCounter++;
while (CurrentToken.code == COMMA)
{
Accept(COMMA);
MakeSymbolTableEntry(STYPE_VARIABLE);
Accept( IDENTIFIER );
ParseVariable();
VarCounter++;
}
Accept(SEMICOLON);
return VarCounter;
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseProcDeclararion implements: */
/* */
/* <ProcDeclaration> :== "PROCEDURE" <Identifier> */
/* [<ParameterList>] ";" [<Declarations>] */
/* {<ProcDeclaration>} <Block> ";" */
/* */
/* Sync Points before [<Declarations>] */
/* before and immediatley after [<ProcDeclarations>] */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseProcDeclaration(void)
{
int VarCounter = 0;
int Add;
SYMBOL *procedure;
scope++;
if ( CurrentToken.code == LEFTPARENTHESIS )
{
ParseParameterList();
}
Accept( SEMICOLON );
Synchronise( &ProgProcDecSet1, &FB_ProcDec );
if ( CurrentToken.code == VAR )
{
ParseDeclarations();
}
Synchronise( &ProgProcDecSet2, &FB_ProcDec );
while ( CurrentToken.code == PROCEDURE )
ParseProcDeclaration();
Synchronise( &ProgProcDecSet2, &FB_ProcDec );
ParseBlock();
Accept( SEMICOLON );
RemoveSymbols( scope );
scope--;
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseParameterList implements: */
/* */
/* <ParameterList> :== "(" <FormalParameter> { "," */
/* <FormalParameter> } ")" */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseParameterList(void)
{
Accept( LEFTPARENTHESIS );
ParseFormalParameter();
while (CurrentToken.code == COMMA)
{
Accept(COMMA);
ParseFormalParameter();
}
Accept(RIGHTPARENTHESIS);
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseFormalParameter implements: */
/* */
/* <FormalParameter> :== [ "REF" ] <Variable> */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseFormalParameter(void)
{
if(CurrentToken.code == REF){
MakeSymbolTableEntry(STYPE_REFPAR);
Accept(REF);
}
MakeSymbolTableEntry(STYPE_VARIABLE);
ParseVariable();
Accept( IDENTIFIER );
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseBlock implements: */
/* */
/* <Block> :== "BEGIN" { <Statement> ";" } "END" */
/* */
/* Sync Points before and immediatley after [<Statement>] */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseBlock(void)
{
Accept(BEGIN);
Synchronise(&StatementFS_aug,&StatementFBS);
Synchronise( &BlockSet1, &FB_Block );
while (CurrentToken.code == IDENTIFIER || CurrentToken.code == WHILE ||
CurrentToken.code == IF || CurrentToken.code == READ ||
CurrentToken.code == WRITE)
{
ParseStatement();
Accept(SEMICOLON);
Synchronise( &StatementFS_aug, &StatementFBS );
Synchronise( &BlockSet1, &FB_Block );
}
Accept(END);
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseStatement implements: */
/* */
/* <Statement> :== <SimpleStatement> | <WhileStatement> | */
/* <IfStatement> | <ReadStatement> | */
/* <WriteStatement> */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseStatement( void )
{
if ( CurrentToken.code == IDENTIFIER ) ParseSimpleStatement();
else if ( CurrentToken.code == WHILE ) ParseWhileStatement();
else if ( CurrentToken.code == IF ) ParseIfStatement();
else if ( CurrentToken.code == READ ) ParseReadStatement();
else if ( CurrentToken.code == WRITE ) ParseWriteStatement();
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseSimpleStatement implements: */
/* */
/* <SimpleStatement> :== <VarOrProcName> <RestOfStatement> */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseSimpleStatement( void )
{
SYMBOL *target;
target = LookupSymbol();
Accept( IDENTIFIER );
ParseRestOfStatement( target );
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseRestOfStatement implements: */
/* */
/* <RestOfStatement> :== <ProcCallList> | <Assignment> | EPSILON */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseRestOfStatement( SYMBOL *target )
{
switch ( CurrentToken.code )
{
case LEFTPARENTHESIS :
ParseProcCallList();
case SEMICOLON :
if ( target != NULL && target->type == STYPE_PROCEDURE )
Emit ( I_CALL, target->address );
else
{
Error( "Not a procedure\n", CurrentToken.pos );
KillCodeGeneration();
}
break;
case ASSIGNMENT :
default :
ParseAssignment();
if ( target != NULL && target->type == STYPE_VARIABLE )
Emit ( I_STOREA, target->address );
else
{
Error( "Undeclared variable\n", CurrentToken.pos );
KillCodeGeneration();
}
break;
}
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseProcCallList implements: */
/* */
/* <ProcCallList> :== "(" <ActualParameter> { "," */
/* <ActualParameter> } ")" */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseProcCallList( void )
{
Accept( LEFTPARENTHESIS );
ParseActualParameter();
while ( CurrentToken.code == COMMA ) {
Accept( COMMA );
ParseActualParameter();
}
Accept( RIGHTPARENTHESIS );
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseAssignment implements: */
/* */
/* <Assignment> :== ":=" <Expression> */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseAssignment(void)
{
Accept(ASSIGNMENT);
ParseExpression();
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseActualParameter implements: */
/* */
/* <ActualParameter> :== <Variable> | <Expression> */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseActualParameter( void )
{
if ( CurrentToken.code == IDENTIFIER ) Accept( IDENTIFIER );
else ParseExpression();
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseWhileStatement implements: */
/* */
/* <WhileStatement> :== "WHILE" <BooleanExpression> "DO" <Block> */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseWhileStatement(void)
{
int Label1, Label2, L2BackPatchLoc;
Accept( WHILE );
Label1 = CurrentCodeAddress();
L2BackPatchLoc = ParseBooleanExpression();
Accept( DO );
ParseBlock();
Emit(I_BR, Label1);
Label2 = CurrentCodeAddress();
BackPatch(L2BackPatchLoc, Label2);
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseIfStatement implements: */
/* */
/* <IfStatement> :== "IF" <BooleanExpression> "THEN" */
/* <Block> [ "ELSE" <Block> ] */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseIfStatement(void)
{
int L1BackPatchLoc, L2BackPatchLoc;
Accept( IF );
L1BackPatchLoc = ParseBooleanExpression();
Accept( THEN );
ParseBlock();
if ( CurrentToken.code == ELSE )
{
L2BackPatchLoc = CurrentCodeAddress();
Emit( I_BR, 999 ); // Branch to TEMP code address,
// to be backpatched later
BackPatch( L1BackPatchLoc, CurrentCodeAddress() );
Accept( ELSE );
ParseBlock();
BackPatch( L2BackPatchLoc, CurrentCodeAddress() );
}
else
BackPatch( L1BackPatchLoc, CurrentCodeAddress() );
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseReadStatement implements: */
/* */
/* <ReadStatement> :== "READ" "(" <Variable> { "," */
/* <Variable> } ")" */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseReadStatement(void)
{
Accept(READ);
Accept( LEFTPARENTHESIS );
Accept( IDENTIFIER );
Read = 1;
ParseProcCallList();
Read = 0;
while (CurrentToken.code == COMMA )
{
Accept( COMMA );
Accept( IDENTIFIER );
}
Accept( RIGHTPARENTHESIS );
_Emit(I_READ);
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseWriteStatement implements: */
/* */
/* <WriteStatement> :== "WRITE" "(" <Expression> { "," */
/* <Expression> } ")" */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseWriteStatement(void)
{
Accept( WRITE );
Accept( LEFTPARENTHESIS );
ParseExpression();
Write = 1;
ParseProcCallList();
while (CurrentToken.code == COMMA ) {
Accept( COMMA );
ParseExpression();
}
Accept( RIGHTPARENTHESIS );
_Emit(I_WRITE);
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseExpression implements: */
/* */
/* <Expression> :== <CompoundTerm> { <AddOp> <CompoundTerm> } */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseExpression(void)
{
int op;
ParseCompoundTerm();
while ( (op = CurrentToken.code) == ADD || /* ADD: name for "+". */
op == SUBTRACT ) /* SUBTRACT: "-". */
{
ParseAddOp();
ParseCompoundTerm();
if(op == ADD) _Emit(I_ADD); else _Emit(I_SUB);
}
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseCompoundTerm implements: */
/* */
/* <CompoundTerm> :== <Term> { <MultOp> <Term> } */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseCompoundTerm( void )
{
int token;
ParseTerm();
while ( (token = CurrentToken.code) == MULTIPLY ||
token == DIVIDE ) {
ParseMultOp();
ParseTerm();
if(token == MULTIPLY) _Emit( I_MULT );
else _Emit( I_DIV );
}
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseTerm implements: */
/* */
/* <Term> :== ["-"] <SubTerm> */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseTerm( void )
{
int negateflag = 0;
if ( CurrentToken.code == SUBTRACT ) {
negateflag = 1;
Accept( SUBTRACT );
}
ParseSubTerm();
if(negateflag) _Emit(I_NEG);
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseTerm implements: */
/* */
/* <BooleanExpression> :== <Expression> <RelOp> <Expression> */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE int ParseBooleanExpression(void)
{
int BackPatchAddr, RelOpInstruction;
ParseExpression();
RelOpInstruction = ParseRelOp();
ParseExpression();
_Emit(I_SUB);
ParseRelOp();
BackPatchAddr = CurrentCodeAddress( );
Emit( RelOpInstruction, 0 ); // Branch to TEMP code address,
// to be backpatched later
return BackPatchAddr;
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseSubTerm implements: */
/* */
/* <SubTerm> :== <Variable> | <IntConst> | "(" <Expression> ")" */
/* */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseSubTerm(void)
{
int i, j;
SYMBOL *var;
switch(CurrentToken.code)
{
case INTCONST:
Emit(I_LOADI,CurrentToken.value);
ParseIntConst();
break;
case LEFTPARENTHESIS:
Accept(LEFTPARENTHESIS);
ParseExpression();
Accept(RIGHTPARENTHESIS);
break;
case IDENTIFIER:
default:
var = LookupSymbol();
if(var != NULL && var->type == STYPE_VARIABLE) {
if (Write) {
Emit(I_LOADA,var->address);
}
else if (Read) {
Emit(I_STOREA,var->address);
}
else {
Emit(I_LOADA,var->address);
}
}
else if ( var->type == STYPE_LOCALVAR ) {
j = scope - var->scope;
if ( j == 0 )
Emit( I_LOADFP, var->address );
else {
_Emit( I_LOADFP );
for ( i = 0; i < j - 1; i++ )
_Emit( I_LOADSP );
Emit( I_LOADSP, var->address );
}
}
else printf("Undeclared Name or Variable");
ParseVariable();
break;
}
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseAddOp implements: */
/* */
/* <AddOp> :== "+" | "-" */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseAddOp( void )
{
if ( CurrentToken.code == ADD ) Accept( ADD );
else Accept ( SUBTRACT );
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseMultOp implements: */
/* */
/* <MultOp> :== "*" | "/" */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseMultOp( void )
{
if ( CurrentToken.code == MULTIPLY ) Accept( MULTIPLY );
else Accept ( DIVIDE );
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseRelOp implements: */
/* */
/* <RelOp> :== "=" | "<=" | ">=" | "<" | ">" */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Int RelOpInstruction */
/* */
/* Side Effects: Lookahead token advanced. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE int ParseRelOp( void )
{
int RelOpInstruction;
switch(CurrentToken.code) {
case LESSEQUAL:
RelOpInstruction = I_BG;
Accept(LESSEQUAL);
break;
case GREATEREQUAL:
RelOpInstruction = I_BL;
Accept(GREATEREQUAL);
break;
case LESS:
RelOpInstruction = I_BGZ;
Accept(LESS);
break;
case EQUALITY:
RelOpInstruction = I_BZ;
Accept(EQUALITY);
break;
case GREATER:
RelOpInstruction = I_BLZ;
Accept(GREATER);
break;
}
return RelOpInstruction;
}
/*--------------------------------------------------------------------------*/
/* */
/* End of parser. Support routines follow. */
/* */
/*--------------------------------------------------------------------------*/
/* */
/* Accept: Takes an expected token name as argument, and if the current */
/* lookahead matches this, advances the lookahead and returns. */
/* */
/* If the expected token fails to match the current lookahead, */
/* this routine reports a syntax error and exits ("crash & burn" */
/* parsing). Note the use of routine "SyntaxError" */
/* (from "scanner.h") which puts the error message on the */
/* standard output and on the listing file, and the helper */
/* "ReadToEndOfFile" which just ensures that the listing file is */
/* completely generated. */
/* */
/* */
/* Inputs: Integer code of expected token */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: If successful, advances the current lookahead token */
/* "CurrentToken". */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void Accept( int ExpectedToken )
{
static int recovering = 0;
/* Error re-sync code */
if( recovering )
{
while( CurrentToken.code != ExpectedToken &&
CurrentToken.code != ENDOFINPUT )
CurrentToken = GetToken();
recovering = 0;
}
/* Normal Accept code */
if( CurrentToken.code != ExpectedToken )
{
SyntaxError( ExpectedToken, CurrentToken );
recovering = 1;
}
else CurrentToken = GetToken();
}
/*--------------------------------------------------------------------------*/
/* */
/* OpenFiles: Reads strings from the command-line and opens the */
/* associated input and listing files. */
/* */
/* Note that this routine mmodifies the globals "InputFile" and */
/* "ListingFile". It returns 1 ("true" in C-speak) if the input and */
/* listing files are successfully opened, 0 if not, allowing the caller */
/* to make a graceful exit if the opening process failed. */
/* */
/* */
/* Inputs: 1) Integer argument count (standard C "argc"). */
/* 2) Array of pointers to C-strings containing arguments */
/* (standard C "argv"). */
/* */
/* Outputs: No direct outputs, but note side effects. */
/* */
/* Returns: Boolean success flag (i.e., an "int": 1 or 0) */
/* */
/* Side Effects: If successful, modifies globals "InputFile" and */
/* "ListingFile". */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE int OpenFiles( int argc, char *argv[] )
{
if ( argc != 4 ) {
fprintf( stderr, "%s <inputfile> <listfile>\n", argv[0] );
return 0;
}
if ( NULL == ( InputFile = fopen( argv[1], "r" ) ) ) {
fprintf( stderr, "cannot open \"%s\" for input\n", argv[1] );
return 0;
}
if ( NULL == ( ListFile = fopen( argv[2], "w" ) ) ) {
fprintf( stderr, "cannot open \"%s\" for output\n", argv[2] );
fclose( InputFile );
return 0;
}
if ( NULL == ( CodeFile = fopen( argv[3], "w" ) ) ) {
fprintf( stderr, "cannot open \"%s\" for output\n", argv[3] );
fclose( InputFile );
fclose( ListFile );
return 0;
}
return 1;
}
/*--------------------------------------------------------------------------*/
/* */
/* ReadToEndOfFile: Reads all remaining tokens from the input file. */
/* associated input and listing files. */
/* */
/* This is used to ensure that the listing file refects the entire */
/* input, even after a syntax error (because of crash & burn parsing, */
/* if a routine like this is not used, the listing file will not be */
/* complete. Note that this routine also reports in the listing file */
/* exactly where the parsing stopped. Note that this routine is */
/* superfluous in a parser that performs error-recovery. */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Nothing */
/* */
/* Side Effects: Reads all remaining tokens from the input. There won't */
/* be any more available input after this routine returns. */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ReadToEndOfFile( void )
{
if ( CurrentToken.code != ENDOFINPUT )
{
Error( "Parsing ends here in this program\n", CurrentToken.pos );
while ( CurrentToken.code != ENDOFINPUT ) CurrentToken = GetToken();
}
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseVariable implements: */
/* */
/* <Variable> :== <Identifier> */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseVariable(void)
{
ParseIdentifier();
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseIntConst implements: */
/* */
/* <IntConst> :== <Digit> { <Digit> } */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseIntConst(void)
{
Accept(INTCONST);
}
/*--------------------------------------------------------------------------*/
/* */
/* ParseIdentifier implements: */
/* */
/* <Identifier> :== <Alpha> { <AlphaNum> } */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void ParseIdentifier(void)
{
Accept(IDENTIFIER);
}
/*--------------------------------------------------------------------------*/
/* */
/* LookupSymbol: Gets 's' field from item in lookahead */
/* (i.e.: CurrentToken.s), and then searches for */
/* a SYMBOL in Symbol Table which has this name. */
/* */
/* */
/* */
/* */
/* Inputs: None */
/* */
/* Outputs: None */
/* */
/* Returns: Stack Pointer variable, sptr */
/* */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE SYMBOL *LookupSymbol ( void )
{
SYMBOL *sptr;
if ( CurrentToken.code == IDENTIFIER )
{
sptr = Probe ( CurrentToken.s, NULL );
if ( sptr == NULL )
{
Error ( "Identifier not declared", CurrentToken.pos );
KillCodeGeneration();
}
}
else sptr = NULL;
return sptr;
}
/*--------------------------------------------------------------------------*/
/* */
/* MakeSymbolTableEntry: Creates symbol table entry for either a */
/* program, variable or procedure */
/* */
/* */
/* */
/* */
/* */
/* Inputs: symtype */
/* */
/* Outputs: None */
/* */
/* Returns: None */
/* */
/* */
/*--------------------------------------------------------------------------*/
PRIVATE void MakeSymbolTableEntry ( int symtype )
{
SYMBOL *oldsptr, *newsptr;
char *cptr;
int hashindex;
static int VarLctn = 0;
if ( CurrentToken.code == IDENTIFIER )
{
if ( NULL == ( oldsptr = Probe ( CurrentToken.s, &hashindex ))
|| oldsptr -> scope < scope )
{
if ( oldsptr == NULL )
cptr = CurrentToken.s;
else
cptr = oldsptr -> s;
if ( NULL == ( newsptr = EnterSymbol ( cptr, hashindex )))
{
Error("Fatal error in EnterSymbol", CurrentToken.pos );
printf("Fatal error in EnterSymbol. ");
printf("Compiler must exit immediately\n");
exit(EXIT_FAILURE);
}
else
{
if ( oldsptr == NULL )
PreserveString();
newsptr -> scope = scope;
newsptr -> type = symtype;
if ( symtype == STYPE_VARIABLE )
{
newsptr -> address = VarLctn;
VarLctn++;
}
else
newsptr -> address = -1;
}
}
else
{
Error("Error! Variable already declared", CurrentToken.pos );
KillCodeGeneration();
}
}
}
|
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
pthread_key_t var;
void destructor(void * p)
{
free(p);
pthread_setspecific(var, NULL);
}
void * Hilo1(void * id)
{
char * valor = (char *) pthread_getspecific(var);
if(valor == NULL)
{
valor = (char *)malloc(10*sizeof(char));
}
sprintf(valor, "HOLA");
pthread_setspecific(var, (void*)valor);
printf("En el hilo 1 var = %s\n", (char*)pthread_getspecific(var));
return NULL;
}
void * Hilo2(void * id)
{
int * valor;
if(pthread_getspecific(var) == NULL)
{
valor = (int *)malloc(sizeof(int));
}
*valor = 100;
pthread_setspecific(var, (void*)valor);
printf("En el hilo 2 var = %d\n", *((int*)pthread_getspecific(var)));
return NULL;
}
int main(int argc, char ** argv)
{
pthread_t tid1, tid2;
pthread_key_create(&var, destructor);
pthread_create(&tid1, NULL, Hilo1, NULL);
pthread_create(&tid2, NULL, Hilo2, NULL);
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
return 0;
}
|
#include "OPF.h"
#include <emscripten.h>
EMSCRIPTEN_KEEPALIVE
void c_opf_classify(int *argc, char **argv)
{
EM_ASM(
FS.syncfs(true, function (err) {
// Error
});
);
errorOccurred = 0;
opf_PrecomputedDistance = 0;
if ((*argc != 4) && (*argc != 3))
{
fprintf(stderr, "\nusage opf_classify <P1> <P2>");
fprintf(stderr, "\nP1: test set in the OPF file format");
fprintf(stderr, "\nP2: OPF model file");
fprintf(stderr, "\nP3: precomputed distance file (leave it in blank if you are not using this resource\n");
return;
}
int n, i, p;
float time;
char fileName[256];
FILE *f = NULL;
timer tic, toc;
if (*argc == 4)
opf_PrecomputedDistance = 1;
fprintf(stdout, "\nReading data files ...");
//sprintf(fileName, "%s.cla", argv[1]);
Subgraph *gTest = ReadSubgraph(argv[1]), *gTrain = opf_ReadModelFile(argv[2]); if(errorOccurred) return;
fprintf(stdout, " OK");
if (opf_PrecomputedDistance){
opf_DistanceValue = opf_ReadDistances(argv[3], &n); if(errorOccurred) return;
int maxPosition = 0;
for (p = 0; p < gTest->nnodes; p++)
{
if(gTest->node[p].position > maxPosition)
maxPosition = gTest->node[p].position;
}
for (p = 0; p < gTrain->nnodes; p++)
{
if(gTrain->node[p].position > maxPosition)
maxPosition = gTrain->node[p].position;
}
if(maxPosition >= n){
errorOccurred = 1;
fprintf(stderr, "\nError! Some positions have no pre-calculated distance, the matrix size must be equal to or less than the maximum position of the nodes");
return;
}
}
fprintf(stdout, "\nClassifying test set ...");
//sprintf(fileName, "%s.pre", argv[1]);
gettimeofday(&tic, NULL);
opf_OPFClassifying(gTrain, gTest);
gettimeofday(&toc, NULL);
fprintf(stdout, " OK");
fprintf(stdout, "\nWriting output file ...");
sprintf(fileName, "%s.out", argv[1]);
opf_WriteOutputFile(gTest, fileName);
fprintf(stdout, " OK");
fprintf(stdout, "\nDeallocating memory ...");
DestroySubgraph(&gTrain);
DestroySubgraph(&gTest);
if (opf_PrecomputedDistance)
{
for (i = 0; i < n; i++)
free(opf_DistanceValue[i]);
free(opf_DistanceValue);
}
fprintf(stdout, " OK\n");
time = ((toc.tv_sec - tic.tv_sec) * 1000.0 + (toc.tv_usec - tic.tv_usec) * 0.001) / 1000.0;
fprintf(stdout, "\nTesting time: %f seconds\n", time);
sprintf(fileName, "%s.tim", argv[1]);
f = fopen(fileName, "a");
fprintf(f, "%f\n", time);
fclose(f);
EM_ASM(
FS.syncfs(function (err) {
// Error
});
);
}
|
#ifndef lint
static char *sccsid = "@(#)siglist.c 1.3 (ULTRIX) 1/29/87";
#endif lint
/************************************************************************
* *
* Copyright (c) 1985 by *
* Digital Equipment Corporation, Maynard, MA *
* All rights reserved. *
* *
* This software is furnished under a license and may be used and *
* copied only in accordance with the terms of such license and *
* with the inclusion of the above copyright notice. This *
* software or any other copies thereof may not be provided or *
* otherwise made available to any other person. No title to and *
* ownership of the software is hereby transferred. *
* *
* This software is derived from software received from the *
* University of California, Berkeley, and from Bell *
* Laboratories. Use, duplication, or disclosure is subject to *
* restrictions under license agreements with University of *
* California and with AT&T. *
* *
* The information in this software is subject to change without *
* notice and should not be construed as a commitment by Digital *
* Equipment Corporation. *
* *
* Digital assumes no responsibility for the use or reliability *
* of its software on equipment which is not supplied by Digital. *
* *
************************************************************************/
/************************************************************************
* Modification History
*
* David L Ballenger, 28-Jun-1985
* 001 Add descriptions for SIGUSR1 and SIGUSR2 from System V.
*
* Based on: siglist.c 4.2 (Berkeley) 2/10/83
*
************************************************************************/
#include <signal.h>
char *sys_siglist[NSIG] = {
"Signal 0",
"Hangup", /* SIGHUP */
"Interrupt", /* SIGINT */
"Quit", /* SIGQUIT */
"Illegal instruction", /* SIGILL */
"Trace/BPT trap", /* SIGTRAP */
"IOT trap", /* SIGIOT */
"EMT trap", /* SIGEMT */
"Floating point exception", /* SIGFPE */
"Killed", /* SIGKILL */
"Bus error", /* SIGBUS */
"Segmentation fault", /* SIGSEGV */
"Bad system call", /* SIGSYS */
"Broken pipe", /* SIGPIPE */
"Alarm clock", /* SIGALRM */
"Terminated", /* SIGTERM */
"Urgent I/O condition", /* SIGURG */
"Stopped (signal)", /* SIGSTOP */
"Stopped", /* SIGTSTP */
"Continued", /* SIGCONT */
"Child exited", /* SIGCHLD */
"Stopped (tty input)", /* SIGTTIN */
"Stopped (tty output)", /* SIGTTOU */
"I/O possible", /* SIGIO */
"Cputime limit exceeded", /* SIGXCPU */
"Filesize limit exceeded", /* SIGXFSZ */
"Virtual timer expired", /* SIGVTALRM */
"Profiling timer expired", /* SIGPROF */
"Window size changes", /* SIGWINCH */
"Signal 29",
"User signal 1", /* SIGUSR1 */
"User signal 2" /* SIGUSR2 */
};
|
/*
* File: invo_bzl.h
* Author: James Xu
*
* Created on 2016.12.17, PM 2:16
*/
#ifndef INVO_BZL_H
#define INVO_BZL_H
#include "commo_header.h"
#include "conve.h"
#include "clas_save.h"
#ifdef __cplusplus
extern "C" {
#endif
// int compbzl_create(char *data_directory);
// int compbzl_destroy();
//
int list_metho_bzl(prod_data *sresp, char *osdb, char *metho);
int list_class_bzl(prod_data *sresp, char *osdb, char *clasn, uint32 etype);
int list_clasd_bzl(char *clas_decl, char *osdb, char *clasn);
// int comp_advance_txt(char *line_txt);
int comp_metho_bzl(char *clang_txt, char *osdb, char *meth_txt);
int robk_metho_bzl(char *osdb, char *meth_txt);
int comp_class_bzl(char *clang_txt, char *osdb, char *clas_decl);
int robk_class_bzl(char *osdb, char *clas_decl);
int comp_imeth_bzl(char *clang_txt, char *osdb, char *meth_txt);
int robk_imeth_bzl(char *osdb, char *clasn, char *metnm, char *parat, char *iclas);
//
int repla_metho_bzl(char *clang_txt, char *osdb, char *meth_txt);
int repla_class_bzl(char *clang_txt, char *osdb, char *clas_decl);
//
int load_metho_bzl(char *clang_txt, char *osdb, char *meth_txt);
int load_class_bzl(char *clang_txt, char *osdb, char *clasn);
//
int dele_metho_bzl(char *osdb, char *methd);
int dele_class_bzl(char *osdb, char *clasn);
//
int class_integri_bzl(char *osdb, char *clasn);
int parse_cdata_bzl(char clas_data[CDATNO_NUMB][PARAM_LENGTH], char *osdb, char *clasn);
//
#define build_handle_bzl(handn, mepan, meth_txt) conve_handle_name(handn, mepan, meth_txt)
#define build_sobje_bzl(sobjn, clasn) build_sobje_txt(sobjn, clasn)
//
int creat_imeth_bzl(char *advan_txt, char *osdb, char *clasn, char *metnm, char *parat, char *iclas);
int drop_imeth_bzl(char *osdb, char *clasn, char *metnm, char *parat, char *iclas);
//
int build_imeth_bzl(char *crea_clas, char *inhe_line, char *iclas[METH_NUMB], char *imeth[METH_NUMB], char *parat[PARAM_NUMB], char *clas_decl);
#ifdef __cplusplus
}
#endif
#endif /* INVO_BZL_H */
|
#include<stdio.h>
void printArray(int a[],int size){
for (int i = 0; i < size; i++)
{
printf("%d ",a[i]);
}
}
int partision(int A[], int low,int high){
int pivot = A[low];
int i = low+1;
int j = high;
int temp;
do
{
while (A[i]<=pivot)
{
i++;
}
while(A[j]>pivot){
j--;
}
if(i<j){
temp=A[i];
A[i]=A[j];
A[j]=temp;
}
} while (i<j);
temp=A[j];
A[j]=A[low];
A[low]=temp;
return j;
}
void quickSort(int A[],int low,int high){
int partisionIndex;
if(low<high){
partisionIndex = partision(A,low,high);
quickSort(A,low,partisionIndex-1);
quickSort(A,partisionIndex+1,high);
}
}
int main()
{
int *A,sizeOfArray;
printf("Enter the Size of the Array : \n");
scanf("%d",&sizeOfArray);
printf("Enter The Array : \n");
for (int i = 0; i < sizeOfArray; i++)
{
scanf("%d",&A[i]);
}
printf("The Original Array is : \n");
printArray(A,sizeOfArray);
quickSort(A,0,sizeOfArray-1);
printf("\nThe Sorted Array is : \n");
printArray(A,sizeOfArray);
return 0;
}
|
#include "geom.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
/* **************************************** */
/* returns the signed area of triangle abc. The area is positive if c
is to the left of ab, and negative if c is to the right of ab
*/
int signed_area2D(point2D a, point2D b, point2D c) {
return ((b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x));
}
/* **************************************** */
/* return 1 if p,q,r collinear, and 0 otherwise */
int collinear(point2D p, point2D q, point2D r) {
return (signed_area2D(p, q, r) == 0);
}
/* **************************************** */
/* return 1 if c is strictly left of ab; 0 otherwise */
int left (point2D a, point2D b, point2D c) {
return (signed_area2D(a, b, c) > 0);
}
/* **************************************** */
/* return 1 if same point*/
int samePoint(point2D a, point2D b){
return ((a.x == b.x) && (a.y == b.y));
}
|
#ifndef ZNPCSPAWNER_H
#define ZNPCSPAWNER_H
#endif
|
/*
* BeanSim : Nand Flash Simulator by File Operations
* Authors: Bean.Li<lishizelibin@163.com>
*
* This file is part of BeanSim.
*
* BeanSim 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.
*
* BeanSim 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 BeanSim. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __COMMON_H__
#define __COMMON_H__
#define BEAN_DEBUG
#define PLATFORM_X86
//#define PLATFORM_ARM
#ifdef PLATFORM_X86
#include <stdio.h> // for printf
#include <stdlib.h>
#include <assert.h> // for assert
#include <stdbool.h>
#include <string.h>
#include <dirent.h>
//#include <io.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#elif defined(PLATFORM_ARM)
// ToDo
#else
// ToDO
#endif // PLATFORM
#ifndef TRUE
#define TRUE true
#endif
#ifndef FALSE
#define FALSE false
#endif
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define HASH_SIZE(n) ((size_t)1 << (n))
#define HASH_MASK(n) (HASH_SIZE(n) - 1)
#define roundup(x,n) (((x)+((n)-1))&(~((n)-1))) // power 2
enum LOG_LEVEL {
LOG_ALL,
LOG_WARN,
LOG_ERR
};
#ifdef BEAN_DEBUG
static enum LOG_LEVEL log_level_stat = LOG_ALL;
#define LOG(level, fmt, ...) \
do { \
if ((level) >= log_level_stat) { \
switch (level) { \
case LOG_WARN: \
printf("[WARN at %s %d]: " fmt "\n", __FILE__, __LINE__, ##__VA_ARGS__); \
break; \
case LOG_ERR: \
printf("[ERROR at %s %d]: " fmt "\n", __FILE__, __LINE__, ##__VA_ARGS__); \
break; \
} \
} \
} while(0)
#define ASSERT(expr) \
do { \
if (!(expr)) { \
LOG(LOG_ERR, "Bean assert fail"); \
assert(0); \
} \
} while(0)
#else
#define LOG(level, fmt, ...)
#define ASSERT(expr)
#endif
static inline unsigned short calc_crc16(unsigned short crc, unsigned char data) {
unsigned short rc;
static const unsigned short crc16_table[] = {
0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,
0x1231,0x0210,0x3273,0x2252,0x52b5,0x4294,0x72f7,0x62d6,
0x9339,0x8318,0xb37b,0xa35a,0xd3bd,0xc39c,0xf3ff,0xe3de,
0x2462,0x3443,0x0420,0x1401,0x64e6,0x74c7,0x44a4,0x5485,
0xa56a,0xb54b,0x8528,0x9509,0xe5ee,0xf5cf,0xc5ac,0xd58d,
0x3653,0x2672,0x1611,0x0630,0x76d7,0x66f6,0x5695,0x46b4,
0xb75b,0xa77a,0x9719,0x8738,0xf7df,0xe7fe,0xd79d,0xc7bc,
0x48c4,0x58e5,0x6886,0x78a7,0x0840,0x1861,0x2802,0x3823,
0xc9cc,0xd9ed,0xe98e,0xf9af,0x8948,0x9969,0xa90a,0xb92b,
0x5af5,0x4ad4,0x7ab7,0x6a96,0x1a71,0x0a50,0x3a33,0x2a12,
0xdbfd,0xcbdc,0xfbbf,0xeb9e,0x9b79,0x8b58,0xbb3b,0xab1a,
0x6ca6,0x7c87,0x4ce4,0x5cc5,0x2c22,0x3c03,0x0c60,0x1c41,
0xedae,0xfd8f,0xcdec,0xddcd,0xad2a,0xbd0b,0x8d68,0x9d49,
0x7e97,0x6eb6,0x5ed5,0x4ef4,0x3e13,0x2e32,0x1e51,0x0e70,
0xff9f,0xefbe,0xdfdd,0xcffc,0xbf1b,0xaf3a,0x9f59,0x8f78,
0x9188,0x81a9,0xb1ca,0xa1eb,0xd10c,0xc12d,0xf14e,0xe16f,
0x1080,0x00a1,0x30c2,0x20e3,0x5004,0x4025,0x7046,0x6067,
0x83b9,0x9398,0xa3fb,0xb3da,0xc33d,0xd31c,0xe37f,0xf35e,
0x02b1,0x1290,0x22f3,0x32d2,0x4235,0x5214,0x6277,0x7256,
0xb5ea,0xa5cb,0x95a8,0x8589,0xf56e,0xe54f,0xd52c,0xc50d,
0x34e2,0x24c3,0x14a0,0x0481,0x7466,0x6447,0x5424,0x4405,
0xa7db,0xb7fa,0x8799,0x97b8,0xe75f,0xf77e,0xc71d,0xd73c,
0x26d3,0x36f2,0x0691,0x16b0,0x6657,0x7676,0x4615,0x5634,
0xd94c,0xc96d,0xf90e,0xe92f,0x99c8,0x89e9,0xb98a,0xa9ab,
0x5844,0x4865,0x7806,0x6827,0x18c0,0x08e1,0x3882,0x28a3,
0xcb7d,0xdb5c,0xeb3f,0xfb1e,0x8bf9,0x9bd8,0xabbb,0xbb9a,
0x4a75,0x5a54,0x6a37,0x7a16,0x0af1,0x1ad0,0x2ab3,0x3a92,
0xfd2e,0xed0f,0xdd6c,0xcd4d,0xbdaa,0xad8b,0x9de8,0x8dc9,
0x7c26,0x6c07,0x5c64,0x4c45,0x3ca2,0x2c83,0x1ce0,0x0cc1,
0xef1f,0xff3e,0xcf5d,0xdf7c,0xaf9b,0xbfba,0x8fd9,0x9ff8,
0x6e17,0x7e36,0x4e55,0x5e74,0x2e93,0x3eb2,0x0ed1,0x1ef0,
};
rc = (crc << 8) ^ crc16_table[(int)(((crc >> 8) ^ data) & 0xff)];
return rc;
}
static inline int fls32(unsigned int x)
{
int r = 32;
if (!x)
return 0;
if (!(x & 0xffff0000u)) {
x <<= 16;
r -= 16;
}
if (!(x & 0xff000000u)) {
x <<= 8;
r -= 8;
}
if (!(x & 0xf0000000u)) {
x <<= 4;
r -= 4;
}
if (!(x & 0xc0000000u)) {
x <<= 2;
r -= 2;
}
if (!(x & 0x80000000u)) {
x <<= 1;
r -= 1;
}
return r;
}
static inline int fls64(unsigned long long x)
{
unsigned int _x = x >> 32;
if (_x)
return fls32(_x) + 32;
return fls32(x);
}
static inline bool is_power_of_2(unsigned long n)
{
return (n != 0 && ((n & (n - 1)) == 0));
}
static inline unsigned long roundup_power2(unsigned long n)
{
if (sizeof(n) == 4)
return 1UL << fls32(n - 1);
return 1UL << fls64(n - 1);
}
static inline unsigned long roundown_power2(unsigned long n)
{
if (sizeof(n) == 4)
return 1UL << (fls32(n) - 1);
return 1UL << (fls64(n) - 1);
}
static inline int calc_msb_index(unsigned int n)
{
unsigned int _n = 1;
if (n == 0)
return -1;
if ((n >> 16) == 0) {
_n += 16;
n <<= 16;
}
if ((n >> 24) == 0) {
_n += 8;
n <<= 8;
}
if ((n >> 28) == 0) {
_n += 4;
n <<= 4;
}
if ((n >> 30) == 0) {
_n += 2;
n <<= 2;
}
_n -= (n >> 31);
return 31 - _n;
}
static inline double power(double n, int p)
{
int i;
double pow = 1;
for (i = 0; i < p; i++)
pow *= n;
return pow;
}
static inline void *mem_alloc(unsigned int size)
{
void *buf;
if (!size)
return NULL;
buf = malloc(size);
if (!buf)
ASSERT(0);
memset(buf, 0, size);
return buf;
}
static inline void mem_free(void *mem)
{
if (mem != NULL)
free(mem);
}
#endif // __COMMON_H__
|
/*
** EPITECH PROJECT, 2017
** key_pressed
** File description:
** Desc
*/
#include "fight.h"
void key_down(t_fight *fight, t_select *select)
{
if (sfKeyboard_isKeyPressed(sfKeyDown) == sfTrue
&& select[0].i == 0)
select_bottom(fight, select);
else if (sfKeyboard_isKeyPressed(sfKeyDown) == sfTrue
&& select[0].i != 0)
select_specific_bottom(fight, select);
}
void key_up(t_fight *fight, t_select *select)
{
if (sfKeyboard_isKeyPressed(sfKeyUp) == sfTrue
&& select[0].i == 0)
select_upper(fight, select);
else if (sfKeyboard_isKeyPressed(sfKeyUp) == sfTrue
&& select[0].i != 0)
select_specific_upper(fight, select);
}
void key_ok(t_fight *fight, t_select *select, t_window *window, wait_t *wait)
{
if (sfKeyboard_isKeyPressed(sfKeyReturn) == sfTrue
&& select[0].i != 0 && select[0].select == 1) {
check_attack(fight, select, window, wait);
}
if (sfKeyboard_isKeyPressed(sfKeyReturn) == sfTrue
&& select[0].i != 0 && select[0].select == 2) {
check_defence(fight, select, window, wait);
}
if (sfKeyboard_isKeyPressed(sfKeyReturn) == sfTrue
&& select[0].i != 0 && select[0].select == 3) {
check_help(fight, select, wait);
sfSprite_setPosition(fight[3].sprite, fight[3].pos_bonus);
sfSprite_setPosition(fight[4].sprite, fight[4].pos_bonus);
}
}
void select_right_left(t_select *select)
{
if (select[0].select == 1)
sfSprite_setPosition(select[0].sprite,
select[0].attack_bot);
if (select[0].select == 2)
sfSprite_setPosition(select[0].sprite,
select[0].def_bot);
if (select[0].select == 3)
sfSprite_setPosition(select[0].sprite,
select[0].bonus_bot);
}
void key_right_left(t_fight *fight, t_select *select, sfEvent event)
{
if (event.type == sfEvtKeyReleased
&& (event.key.code == sfKeyReturn
|| event.key.code == sfKeyRight)
&& select[0].i == 0) {
select[0].i = 1;
select[0].visible = 1;
}
if (event.type == sfEvtKeyReleased
&& (event.key.code == sfKeyBack
|| event.key.code == sfKeyLeft)
&& select[0].i != 0) {
select[0].i = 0;
select[0].visible = 0;
select[0].specifics = 1;
sfSprite_setPosition(fight[2].sprite, fight[2].pos_def);
select_right_left(select);
}
}
|
/*
* rc.h
*
* Created on: 05.04.2016
* Author: Arndt
*/
#ifndef RC_H_
#define RC_H_
#include <Arduino.h>
#include <FreeRTOS.h>
#include <FreeRTOSConfig.h>
#include <task.h>
#include <RCSwitch.h>
#include <FiFo.h>
#include "defines.h"
enum rc_type {
A=0,
B=1,
C=2,
D=3
};
struct RcQueueTxCommand {
int protocol; // timing characteristics 1..5 (default 1)
rc_type type;
char family;
char group;
char device;
bool state;
};
struct RcQueueRxEntry {
unsigned int protocol;
unsigned long value;
};
extern FiFo RcSendQueue;
extern FiFo RcReceiveQueue;
extern FiFo RcMsgBuffer;
extern RCSwitch RcSwitch;
extern bool rc_rxen;
extern bool rc_txen;
extern int rc_txrepeat;
extern int rc_protocol;
void remoteControlSetup();
void remoteControlLoop();
#endif /* RC_H_ */
|
/* Copyright (c) 2013 The F9 Microkernel Project. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include <os/platform/debug_device.h>
#include <errno.h>
#include <os/types.h>
#ifdef CONFIG_DEBUG_DEV_UART
//#include <os/debug_uart.h>
#endif
#ifdef CONFIG_DEBUG_DEV_RAM
#include <os/debug_ram.h>
#endif
#ifdef DEBUG_DEVICE_EXIST
static dbg_dev_t dbg_dev[DBG_DEV_MAX];
static dbg_dev_t *cur_dev = &dbg_dev[0];
static uint8_t default_getchar(void)
{
return (EOF);
}
static void default_putchar(uint8_t chr)
{
chr = 0;
}
static void default_start_panic(void)
{
}
/*
* Receive a character from debug port
*/
uint8_t dbg_getchar(void)
{
return ((*cur_dev->getchar)());
}
/*
* Send a character to debug port
*/
void dbg_putchar(uint8_t chr)
{
(*cur_dev->putchar)(chr);
}
/*
* Do the preparing before entering panic. Previous characters in
* debug queue must be flushed out first.
*/
void dbg_start_panic(void)
{
if (!cur_dev || !cur_dev->start_panic)
return;
(*cur_dev->start_panic)();
}
/*
* Initialization procedure for debug IO port
*/
static void dbg_device_init(void)
{
int i;
for (i = 0; i < (DBG_DEV_MAX - 1); i++) {
dbg_dev_t *pdev = &dbg_dev[i];
pdev->dev_id = DBG_DEV_MAX;
pdev->getchar = default_getchar;
pdev->putchar = default_putchar;
pdev->start_panic = default_start_panic;
}
#ifdef CONFIG_DEBUG_DEV_UART
dbg_uart_init();
#endif
#ifdef CONFIG_DEBUG_DEV_RAM
dbg_ram_init();
#endif
}
/*
* Register device IO port objects
*/
int32_t dbg_register_device(dbg_dev_t *device)
{
dbg_dev_t *pdev;
if (!device)
return -EINVAL;
if (device->dev_id >= DBG_DEV_MAX)
return -EINVAL;
pdev = &dbg_dev[device->dev_id];
pdev->dev_id = device->dev_id;
pdev->getchar = device->getchar;
pdev->putchar = device->putchar;
pdev->start_panic = device->start_panic;
return 0;
}
int32_t dbg_change_device(dbg_dev_id_t dev_id)
{
if (dev_id >= DBG_DEV_MAX)
return -EINVAL;
if (dbg_dev[dev_id].dev_id == DBG_DEV_MAX)
return -ENXIO;
cur_dev = &dbg_dev[dev_id];
return 0;
}
#else /* DEBUG_DEVICE_EXIST */
uint8_t dbg_getchar(void)
{
return (EOF);
}
void dbg_putchar(uint8_t chr)
{
chr = 0;
}
void dbg_start_panic(void)
{
}
#endif /* DEBUG_DEVICE_EXIST */
#ifdef CONFIG_DEBUG
extern dbg_layer_t dbg_layer;
void dbg_device_init_hook(void)
{
#ifdef DEBUG_DEVICE_EXIST
dbg_device_init();
#endif
dbg_layer = DL_KDB;
}
INIT_HOOK(dbg_device_init_hook, INIT_LEVEL_PLATFORM);
#endif
#ifdef CONFIG_STDIO_USE_DBGPORT
uint8_t __l4_getchar(void)
__attribute__((weak, alias("dbg_getchar")));
void __l4_putchar(uint8_t chr)
__attribute__((weak, alias("dbg_putchar")));
#endif
|
/*
FuseCompress
Copyright (C) 2005 Milan Svoboda <milan.svoboda@centrum.cz>
(C) 2011 Ulrich Hecht <uli@suse.de>
*/
#include "structs.h"
extern int min_filesize_background;
extern int root_fs;
extern int read_only;
extern int cache_decompressed_data;
extern int decomp_cache_size;
extern int max_decomp_cache_size;
extern size_t dont_compress_beyond;
extern int dedup_enabled;
extern int dedup_redup;
#define DC_PAGE_SIZE (4096)
extern pthread_t pt_comp;
extern pthread_mutexattr_t locktype;
extern compressor_t *compressor_default;
extern compressor_t *compressors[5];
extern char *incompressible[];
extern char **user_incompressible;
extern char **user_exclude_paths;
extern char *mmapped_dirs[];
extern database_t database;
extern database_t comp_database;
void *thread_compress(void *arg);
#define PCFS_PREFIX "._fC"
#define TEMP PCFS_PREFIX "tmp" /* Template is: ._.tmpXXXXXX */
#define FUSE ".fuse_hidden" /* Temporary FUSE file */
#define DEDUP_DB_FILE PCFS_PREFIX "dedup_db"
#define DEDUP_ATTR PCFS_PREFIX "at_"
extern char compresslevel[];
#define COMPRESSLEVEL_BACKGROUND (compresslevel) /* See above, this is for background compress */
// Gcc optimizations
//
#if __GNUC__ >= 3
# define likely(x) __builtin_expect (!!(x), 1)
# define unlikely(x) __builtin_expect (!!(x), 0)
#else
# define likely(x) (x)
# define unlikely(x) (x)
#endif
|
#include <keyboard.h>
#include <print.h>
#include <8259A.h>
#include <int.h>
#include <x86.h>
extern unsigned char scancode_types[];
extern char scancode_ascii[];
extern char scancode_shift_ascii[];
void key_putc(char);
static struct key_desc keys;
void keyboard_interrupt(struct regs *reg)
{
/*
* We must read this scan code from the buffer
* otherwise the keyboard interrupt will be closed.
*/
u8 scan_code = inb(0x60);
u8 press = 1;
int type;
char c;
/* Just skip prefix code: 0xE0 */
if (scan_code == KEY_E0)
return;
/* scan code of pause key: 0xe1 0x1d 0x45 0xe1 0x4d 0xc5 */
if (scan_code == KEY_E1 || keys.pause) {
keys.pause = 1;
if (scan_code == 0xc5)
keys.pause = 0;
return;
}
if (scan_code & KEY_RELEASE_BIT) {
scan_code &= 0x7f;
press = 0;
}
/* get scancode types */
type = scancode_types[scan_code];
/* handle none code */
if (press && type == KEY_NONE) {
printk("None scan code: %x\n", scan_code);
return;
}
/* handle prefix code */
if (scancode_types[scan_code] == KEY_PREFIX) {
switch (scan_code) {
case KEY_ESC:
keys.esc = press;
break;
case KEY_CAPSLOCK:
if (press)
keys.capslock = !keys.capslock;
break;
case KEY_LSHIFT:
case KEY_RSHIFT:
keys.shift = press;
break;
case KEY_START:
keys.start = press;
break;
case KEY_ALT:
keys.alt = press;
break;
case KEY_CTRL:
keys.ctrl = press;
break;
}
return;
}
/* handle acsii scan code */
if (press && type == KEY_ASCII) {
if (keys.capslock || keys.shift)
c = scancode_shift_ascii[scan_code];
else
c = scancode_ascii[scan_code];
/* EOF */
if ((c == 'd' || c == 'D') && keys.ctrl)
c = '\0';
key_putc(c);
}
}
void keyboard_init(void)
{
/* open keyboard interrupt */
unmask_8259A(IRQ_KEYBOARD);
}
|
#include <stdio.h>
#include <stdlib.h>
#include "linkedlist.h"
void addFirst(int d){
Node * newNode =
}
void printList(){
if (head==NULL)
printf("Emptylist\n");
else
}
|
#ifndef FUNCIONES_H_INCLUDED
#define FUNCIONES_H_INCLUDED
#endif // FUNCIONES_H_INCLUDED
float numeroA();
/** \brief numeroA obtiene un numero para 1er operando ingresado por el usuario.
*
* \param num guarda el numero ingresado.
* \return num devuelve el valor ingresado.
*
*/
float numeroB();
/** \brief numeroA obtiene un numero para 1er operando ingresado por el usuario.
*
* \param num guarda el numero ingresado.
* \return num devuelve el valor ingresado.
*
*/
float suma(float a, float b);
/** \brief suma los dos numeros que obtiene de numeroA y numeroB.
*
* \param suma, obtiene el valor de la suma de x e y.
* \param a tiene el valor de numeroA.
* \param b tiene el valor de numeroB.
* \return devuelve el resultado.
*
*/
float resta(float a, float b);
/** \brief resta los dos numeros que obtiene de numeroA y numeroB.
*
* \param resta, obtiene el valor de la resta de x e y.
* \param a tiene el valor de numeroA.
* \param b tiene el valor de numeroB.
* \return devuelve el resultado.
*
*/
float division(float a, float b);
/** \brief divide los dos numeros que obtiene de numeroA y numeroB.
*
* \param division, obtiene el valor de la division de x e y.
* \param a tiene el valor de numeroA.
* \param b tiene el valor de numeroB.
* \return devuelve el resultado.
*
*/
float multiplicacion(float a, float b);
/** \brief multiplica los dos numeros que obtiene de numeroA y numeroB.
*
* \param multiplicacion, obtiene el valor de la multiplicacion de x e y.
* \param a tiene el valor de numeroA.
* \param b tiene el valor de numeroB.
* \return devuelve el resultado.
*
*/
float factorial(float a);
/** \brief factorialA, hace la factorizacion de numeroA.
*
* \param fact 1 valor que se multiplica con i.
* \param i obtiene el valor de numeroA.
* \return fact devuelve el factoreo.
*
*/
|
/*
* 1wire_bus.h
*
* Created on: 2020年11月30日
* Author: tom
*/
#ifndef ONE_WIRE_BUS_H_
#define ONE_WIRE_BUS_H_
#include "gpio.h"
#define ONE_WIRE_SEARCH_ROM 0xF0
#define ONE_WIRE_READ_ROM 0x33
#define ONE_WIRE_MATCH_ROM 0x55
#define ONE_WIRE_SKIP_ROM 0xCC
#define ONE_WIRE_ALARM_SEARCH 0xEC
#define one_wire_bus P15//P35
unsigned char one_wire_bus_present();
void one_wire_bus_write(unsigned char value);
unsigned char one_wire_bus_read();
/*
* search the device rom on the bus
*
* alarm_search !=0 perform alarm searching.
* *result will save in the search result , which point to the memory has alloced more than n_rom x 8 byte .
* n_rom limit the number of device of searching.
*
* return the number of devices which has been found.
*/
unsigned char one_wire_bus_search_rom(unsigned char alarm_search ,unsigned char *result,unsigned char n_rom);
void one_wire_bus_read_rom(unsigned char *result);
void one_wire_bus_match_rom(unsigned char *rom);
#endif /* 1WIRE_BUS_H_ */
|
void fit_mjj_Full_PFNo3Dijet2017bgCSVv2le1b800()
{
//=========Macro generated from canvas: c/c
//========= (Thu Sep 20 01:51:07 2018) by ROOT version6.02/05
TCanvas *c = new TCanvas("c", "c",0,0,600,700);
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
c->SetHighLightColor(2);
c->Range(0,0,1,1);
c->SetFillColor(0);
c->SetBorderMode(0);
c->SetBorderSize(2);
c->SetTopMargin(0.04761905);
c->SetBottomMargin(0.05);
c->SetFrameBorderMode(0);
// ------------>Primitives in pad: c_1
TPad *c_1 = new TPad("c_1", "c_1",0.01,0.37,0.99,0.98);
c_1->Draw();
c_1->cd();
c_1->Range(2.91482,-7.69897,3.947382,1.774714);
c_1->SetFillColor(0);
c_1->SetBorderMode(0);
c_1->SetBorderSize(2);
c_1->SetLogx();
c_1->SetLogy();
c_1->SetLeftMargin(0.175);
c_1->SetRightMargin(0.05);
c_1->SetTopMargin(0.05);
c_1->SetBottomMargin(0);
c_1->SetFrameFillStyle(0);
c_1->SetFrameBorderMode(0);
c_1->SetFrameFillStyle(0);
c_1->SetFrameBorderMode(0);
Double_t xAxis1[45] = {1246, 1313, 1383, 1455, 1530, 1607, 1687, 1770, 1856, 1945, 2037, 2132, 2231, 2332, 2438, 2546, 2659, 2775, 2895, 3019, 3147, 3279, 3416, 3558, 3704, 3854, 4010, 4171, 4337, 4509, 4686, 4869, 5058, 5253, 5455, 5663, 5877, 6099, 6328, 6564, 6808, 7060, 7320, 7589, 7866};
TH1D *data_obs_density1 = new TH1D("data_obs_density1","",44, xAxis1);
data_obs_density1->SetMinimum(2e-08);
data_obs_density1->SetMaximum(20);
data_obs_density1->SetEntries(10044);
data_obs_density1->SetLineColor(0);
data_obs_density1->SetLineWidth(0);
data_obs_density1->SetMarkerColor(0);
data_obs_density1->GetXaxis()->SetRange(1,44);
data_obs_density1->GetXaxis()->SetLabelFont(42);
data_obs_density1->GetXaxis()->SetLabelSize(0.035);
data_obs_density1->GetXaxis()->SetTitleSize(0.035);
data_obs_density1->GetXaxis()->SetTitleFont(42);
data_obs_density1->GetYaxis()->SetTitle("d#sigma/dm_{jj} [pb/TeV]");
data_obs_density1->GetYaxis()->SetLabelFont(42);
data_obs_density1->GetYaxis()->SetLabelOffset(1000);
data_obs_density1->GetYaxis()->SetLabelSize(0.05);
data_obs_density1->GetYaxis()->SetTitleSize(0.07);
data_obs_density1->GetYaxis()->SetTitleFont(42);
data_obs_density1->GetZaxis()->SetLabelFont(42);
data_obs_density1->GetZaxis()->SetLabelSize(0.035);
data_obs_density1->GetZaxis()->SetTitleSize(0.035);
data_obs_density1->GetZaxis()->SetTitleFont(42);
data_obs_density1->Draw("axis");
TF1 *PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1 = new TF1("*PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin",1246,7866,1);
//The original function : had originally been created by:
//TF1 *PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin = new TF1("PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin",,1246,7866,1);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetRange(1246,7866);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetName("PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin");
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetTitle("");
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(0,0.001111603);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(1,0.002284628);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(2,0.004033681);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(3,0.006251862);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(4,0.008661882);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(5,0.0108931);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(6,0.01259698);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(7,0.01354482);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(8,0.01367127);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(9,0.01306005);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(10,0.01189264);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(11,0.01038741);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(12,0.008749664);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(13,0.007141719);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(14,0.005672396);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(15,0.004400444);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(16,0.003345209);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(17,0.002499307);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(18,0.001840012);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(19,0.001337954);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(20,0.0009629226);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(21,0.0006872093);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(22,0.0004871592);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(23,0.0003435596);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(24,0.0002413707);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(25,0.0001691468);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(26,0.0001183684);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(27,8.28042e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(28,5.795953e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(29,4.062842e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(30,2.854383e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(31,2.011354e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(32,1.42249e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(33,1.010329e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(34,7.210679e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(35,5.173907e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(36,3.734239e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(37,2.712213e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(38,1.983202e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(39,1.460505e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(40,1.083656e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(41,8.103696e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(42,6.10968e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(43,4.645478e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(44,3.563235e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(45,2.757906e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(46,2.154508e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(47,1.699254e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(48,1.353356e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(49,1.0887e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(50,8.847927e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(51,7.266121e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(52,6.030867e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(53,5.060093e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(54,4.292616e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(55,3.682573e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(56,3.195408e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(57,2.804947e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(58,2.491285e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(59,2.23923e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(60,2.037163e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(61,1.876202e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(62,1.749583e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(63,1.652211e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(64,1.580326e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(65,1.531276e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(66,1.503354e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(67,1.495705e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(68,1.508288e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(69,1.541894e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(70,1.598216e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(71,1.679993e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(72,1.791233e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(73,1.937549e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(74,2.126642e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(75,2.368993e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(76,2.678861e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(77,3.075703e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(78,3.586245e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(79,4.247494e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(80,5.111186e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(81,6.2504e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(82,7.769549e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(83,9.819584e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(84,1.262149e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(85,1.6503e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(86,2.195674e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(87,2.973362e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(88,4.099479e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(89,5.756269e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(90,8.234174e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(91,1.200343e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(92,1.783783e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(93,2.703211e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(94,4.179025e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(95,6.593085e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(96,1.061913e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(97,1.746825e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(98,2.935971e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(99,5.0441e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(100,8.862192e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(101,1246);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetSavedPoint(102,7866);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetFillColor(19);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetFillStyle(0);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetLineColor(2);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetLineWidth(2);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->GetXaxis()->SetLabelFont(42);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->GetXaxis()->SetLabelSize(0.035);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->GetXaxis()->SetTitleSize(0.035);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->GetXaxis()->SetTitleFont(42);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->GetYaxis()->SetLabelFont(42);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->GetYaxis()->SetLabelSize(0.035);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->GetYaxis()->SetTitleSize(0.035);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->GetYaxis()->SetTitleFont(42);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetParameter(0,2.722925e-79);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetParError(0,0);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->SetParLimits(0,0,0);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin1->Draw("csame");
TLatex * tex = new TLatex(0.72,0.96,"41.8 fb^{-1} (13 TeV)");
tex->SetNDC();
tex->SetTextFont(42);
tex->SetTextSize(0.045);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0.22,0.89,"CMS");
tex->SetNDC();
tex->SetTextSize(0.065);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0.32,0.89,"Preliminary");
tex->SetNDC();
tex->SetTextFont(52);
tex->SetTextSize(0.045);
tex->SetLineWidth(2);
tex->Draw();
TLegend *leg = new TLegend(0.6,0.58,0.89,0.94,NULL,"brNDC");
leg->SetBorderSize(1);
leg->SetLineColor(0);
leg->SetLineStyle(1);
leg->SetLineWidth(0);
leg->SetFillColor(0);
leg->SetFillStyle(0);
TLegendEntry *entry=leg->AddEntry("Graph_from_data_obs_rebin","Data","pe");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(20);
entry->SetMarkerSize(0.9);
entry->SetTextFont(42);
entry=leg->AddEntry("PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin","Fit","l");
entry->SetLineColor(2);
entry->SetLineStyle(1);
entry->SetLineWidth(2);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(21);
entry->SetMarkerSize(1);
entry->SetTextFont(42);
leg->Draw();
TPaveText *pt = new TPaveText(0.2,0.03,0.5,0.23,"brNDC");
pt->SetBorderSize(0);
pt->SetFillColor(0);
pt->SetFillStyle(0);
pt->SetTextAlign(11);
pt->SetTextFont(42);
pt->SetTextSize(0.045);
AText = pt->AddText("#chi^{2} / ndf = 467006.9 / 33 = 14151.7");
AText = pt->AddText("Wide PF-jets");
AText = pt->AddText("m_{jj} > 1.25 TeV");
AText = pt->AddText("|#eta| < 2.5, |#Delta#eta| < 1.3");
pt->Draw();
TF1 *PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2 = new TF1("*PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin",1246,7866,1);
//The original function : had originally been created by:
//TF1 *PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin = new TF1("PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin",,1246,7866,1);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetRange(1246,7866);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetName("PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin");
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetTitle("");
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(0,0.001111603);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(1,0.002284628);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(2,0.004033681);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(3,0.006251862);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(4,0.008661882);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(5,0.0108931);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(6,0.01259698);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(7,0.01354482);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(8,0.01367127);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(9,0.01306005);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(10,0.01189264);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(11,0.01038741);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(12,0.008749664);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(13,0.007141719);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(14,0.005672396);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(15,0.004400444);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(16,0.003345209);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(17,0.002499307);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(18,0.001840012);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(19,0.001337954);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(20,0.0009629226);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(21,0.0006872093);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(22,0.0004871592);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(23,0.0003435596);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(24,0.0002413707);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(25,0.0001691468);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(26,0.0001183684);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(27,8.28042e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(28,5.795953e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(29,4.062842e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(30,2.854383e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(31,2.011354e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(32,1.42249e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(33,1.010329e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(34,7.210679e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(35,5.173907e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(36,3.734239e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(37,2.712213e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(38,1.983202e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(39,1.460505e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(40,1.083656e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(41,8.103696e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(42,6.10968e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(43,4.645478e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(44,3.563235e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(45,2.757906e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(46,2.154508e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(47,1.699254e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(48,1.353356e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(49,1.0887e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(50,8.847927e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(51,7.266121e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(52,6.030867e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(53,5.060093e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(54,4.292616e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(55,3.682573e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(56,3.195408e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(57,2.804947e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(58,2.491285e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(59,2.23923e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(60,2.037163e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(61,1.876202e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(62,1.749583e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(63,1.652211e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(64,1.580326e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(65,1.531276e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(66,1.503354e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(67,1.495705e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(68,1.508288e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(69,1.541894e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(70,1.598216e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(71,1.679993e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(72,1.791233e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(73,1.937549e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(74,2.126642e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(75,2.368993e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(76,2.678861e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(77,3.075703e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(78,3.586245e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(79,4.247494e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(80,5.111186e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(81,6.2504e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(82,7.769549e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(83,9.819584e-08);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(84,1.262149e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(85,1.6503e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(86,2.195674e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(87,2.973362e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(88,4.099479e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(89,5.756269e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(90,8.234174e-07);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(91,1.200343e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(92,1.783783e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(93,2.703211e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(94,4.179025e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(95,6.593085e-06);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(96,1.061913e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(97,1.746825e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(98,2.935971e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(99,5.0441e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(100,8.862192e-05);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(101,1246);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetSavedPoint(102,7866);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetFillColor(19);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetFillStyle(0);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetLineColor(2);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetLineWidth(2);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->GetXaxis()->SetLabelFont(42);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->GetXaxis()->SetLabelSize(0.035);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->GetXaxis()->SetTitleSize(0.035);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->GetXaxis()->SetTitleFont(42);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->GetYaxis()->SetLabelFont(42);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->GetYaxis()->SetLabelSize(0.035);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->GetYaxis()->SetTitleSize(0.035);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->GetYaxis()->SetTitleFont(42);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetParameter(0,2.722925e-79);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetParError(0,0);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->SetParLimits(0,0,0);
PFNo3Dijet2017bgCSVv2le1b800_bkg_unbin2->Draw("csame");
Double_t g_data_clone_fx3001[44] = {
1279.5,
1348,
1419,
1492.5,
1568.5,
1647,
1728.5,
1813,
1900.5,
1991,
2084.5,
2181.5,
2281.5,
2385,
2492,
2602.5,
2717,
2835,
2957,
3083,
3213,
3347.5,
3487,
3631,
3779,
3932,
4090.5,
4254,
4423,
4597.5,
4777.5,
4963.5,
5155.5,
5354,
5559,
5770,
5988,
6213.5,
6446,
6686,
6934,
7190,
7454.5,
7727.5};
Double_t g_data_clone_fy3001[44] = {
0,
0,
0,
0.0004446571,
0.02931616,
0.0217488,
0.01611316,
0.01183682,
0.008838235,
0.006499376,
0.004794762,
0.003545261,
0.002604339,
0.001968493,
0.00142566,
0.001065123,
0.0007744184,
0.0005727671,
0.0004275351,
0.0002945574,
0.0002287226,
0.0001569867,
0.0001088348,
8.864783e-05,
6.698565e-05,
4.81536e-05,
3.165027e-05,
2.262639e-05,
1.488261e-05,
1.13535e-05,
8.366669e-06,
6.328954e-06,
2.576371e-06,
4.263584e-06,
1.610232e-06,
1.341502e-06,
1.077633e-06,
5.22346e-07,
6.082232e-07,
1.960938e-07,
0,
0,
0,
0};
Double_t g_data_clone_felx3001[44] = {
33.5,
35,
36,
37.5,
38.5,
40,
41.5,
43,
44.5,
46,
47.5,
49.5,
50.5,
53,
54,
56.5,
58,
60,
62,
64,
66,
68.5,
71,
73,
75,
78,
80.5,
83,
86,
88.5,
91.5,
94.5,
97.5,
101,
104,
107,
111,
114.5,
118,
122,
126,
130,
134.5,
138.5};
Double_t g_data_clone_fely3001[44] = {
0,
0,
0,
1.190834e-05,
9.543962e-05,
8.064788e-05,
6.815085e-05,
5.738361e-05,
4.874239e-05,
4.111121e-05,
3.474875e-05,
2.927001e-05,
2.483721e-05,
2.107788e-05,
1.777076e-05,
1.501645e-05,
1.263749e-05,
1.068549e-05,
9.081624e-06,
7.419167e-06,
6.437708e-06,
5.234938e-06,
4.281033e-06,
3.810172e-06,
3.267334e-06,
2.716076e-06,
2.166984e-06,
1.803896e-06,
1.436534e-06,
1.236323e-06,
1.043115e-06,
8.920629e-07,
5.577097e-07,
7.072944e-07,
4.251664e-07,
3.818054e-07,
3.350088e-07,
2.256247e-07,
2.412587e-07,
1.266599e-07,
0,
0,
0,
0};
Double_t g_data_clone_fehx3001[44] = {
33.5,
35,
36,
37.5,
38.5,
40,
41.5,
43,
44.5,
46,
47.5,
49.5,
50.5,
53,
54,
56.5,
58,
60,
62,
64,
66,
68.5,
71,
73,
75,
78,
80.5,
83,
86,
88.5,
91.5,
94.5,
97.5,
101,
104,
107,
111,
114.5,
118,
122,
126,
130,
134.5,
138.5};
Double_t g_data_clone_fehy3001[44] = {
6.573787e-07,
6.292053e-07,
6.117274e-07,
1.22316e-05,
9.575083e-05,
8.094749e-05,
6.84397e-05,
5.766247e-05,
4.901194e-05,
4.137208e-05,
3.500149e-05,
2.951266e-05,
2.507521e-05,
2.130479e-05,
1.799366e-05,
1.522966e-05,
1.284541e-05,
1.088672e-05,
9.276611e-06,
7.60843e-06,
6.621505e-06,
5.412482e-06,
4.45283e-06,
3.977562e-06,
3.430724e-06,
2.873769e-06,
2.32068e-06,
1.953778e-06,
1.582365e-06,
1.378878e-06,
1.182038e-06,
1.027619e-06,
6.938164e-07,
8.35626e-07,
5.555851e-07,
5.097607e-07,
4.598297e-07,
3.533711e-07,
3.632828e-07,
2.586389e-07,
1.747793e-07,
1.694014e-07,
1.637337e-07,
1.59005e-07};
TGraphAsymmErrors *grae = new TGraphAsymmErrors(44,g_data_clone_fx3001,g_data_clone_fy3001,g_data_clone_felx3001,g_data_clone_fehx3001,g_data_clone_fely3001,g_data_clone_fehy3001);
grae->SetName("g_data_clone");
grae->SetTitle("");
grae->SetMarkerStyle(20);
grae->SetMarkerSize(0);
TH1F *Graph_g_data_clone3001 = new TH1F("Graph_g_data_clone3001","",100,584,8528);
Graph_g_data_clone3001->SetMinimum(3.23531e-05);
Graph_g_data_clone3001->SetMaximum(0.0323531);
Graph_g_data_clone3001->SetDirectory(0);
Graph_g_data_clone3001->SetStats(0);
Int_t ci; // for color index setting
TColor *color; // for color definition with alpha
ci = TColor::GetColor("#000099");
Graph_g_data_clone3001->SetLineColor(ci);
Graph_g_data_clone3001->GetXaxis()->SetLabelFont(42);
Graph_g_data_clone3001->GetXaxis()->SetLabelSize(0.035);
Graph_g_data_clone3001->GetXaxis()->SetTitleSize(0.035);
Graph_g_data_clone3001->GetXaxis()->SetTitleFont(42);
Graph_g_data_clone3001->GetYaxis()->SetLabelFont(42);
Graph_g_data_clone3001->GetYaxis()->SetLabelSize(0.035);
Graph_g_data_clone3001->GetYaxis()->SetTitleSize(0.035);
Graph_g_data_clone3001->GetYaxis()->SetTitleFont(42);
Graph_g_data_clone3001->GetZaxis()->SetLabelFont(42);
Graph_g_data_clone3001->GetZaxis()->SetLabelSize(0.035);
Graph_g_data_clone3001->GetZaxis()->SetTitleSize(0.035);
Graph_g_data_clone3001->GetZaxis()->SetTitleFont(42);
grae->SetHistogram(Graph_g_data_clone3001);
grae->Draw("zp");
Double_t Graph_from_data_obs_rebin_fx3002[44] = {
1279.5,
1348,
1419,
1492.5,
1568.5,
1647,
1728.5,
1813,
1900.5,
1991,
2084.5,
2181.5,
2281.5,
2385,
2492,
2602.5,
2717,
2835,
2957,
3083,
3213,
3347.5,
3487,
3631,
3779,
3932,
4090.5,
4254,
4423,
4597.5,
4777.5,
4963.5,
5155.5,
5354,
5559,
5770,
5988,
6213.5,
6446,
6686,
6934,
7190,
7454.5,
7727.5};
Double_t Graph_from_data_obs_rebin_fy3002[44] = {
99999,
99999,
99999,
0.0004446571,
0.02931616,
0.0217488,
0.01611316,
0.01183682,
0.008838235,
0.006499376,
0.004794762,
0.003545261,
0.002604339,
0.001968493,
0.00142566,
0.001065123,
0.0007744184,
0.0005727671,
0.0004275351,
0.0002945574,
0.0002287226,
0.0001569867,
0.0001088348,
8.864783e-05,
6.698565e-05,
4.81536e-05,
3.165027e-05,
2.262639e-05,
1.488261e-05,
1.13535e-05,
8.366669e-06,
6.328954e-06,
2.576371e-06,
4.263584e-06,
1.610232e-06,
1.341502e-06,
1.077633e-06,
5.22346e-07,
6.082232e-07,
1.960938e-07,
99999,
99999,
99999,
99999};
Double_t Graph_from_data_obs_rebin_felx3002[44] = {
33.5,
35,
36,
37.5,
38.5,
40,
41.5,
43,
44.5,
46,
47.5,
49.5,
50.5,
53,
54,
56.5,
58,
60,
62,
64,
66,
68.5,
71,
73,
75,
78,
80.5,
83,
86,
88.5,
91.5,
94.5,
97.5,
101,
104,
107,
111,
114.5,
118,
122,
126,
130,
134.5,
138.5};
Double_t Graph_from_data_obs_rebin_fely3002[44] = {
0,
0,
0,
1.190834e-05,
9.543962e-05,
8.064788e-05,
6.815085e-05,
5.738361e-05,
4.874239e-05,
4.111121e-05,
3.474875e-05,
2.927001e-05,
2.483721e-05,
2.107788e-05,
1.777076e-05,
1.501645e-05,
1.263749e-05,
1.068549e-05,
9.081624e-06,
7.419167e-06,
6.437708e-06,
5.234938e-06,
4.281033e-06,
3.810172e-06,
3.267334e-06,
2.716076e-06,
2.166984e-06,
1.803896e-06,
1.436534e-06,
1.236323e-06,
1.043115e-06,
8.920629e-07,
5.577097e-07,
7.072944e-07,
4.251664e-07,
3.818054e-07,
3.350088e-07,
2.256247e-07,
2.412587e-07,
1.266599e-07,
0,
0,
0,
0};
Double_t Graph_from_data_obs_rebin_fehx3002[44] = {
33.5,
35,
36,
37.5,
38.5,
40,
41.5,
43,
44.5,
46,
47.5,
49.5,
50.5,
53,
54,
56.5,
58,
60,
62,
64,
66,
68.5,
71,
73,
75,
78,
80.5,
83,
86,
88.5,
91.5,
94.5,
97.5,
101,
104,
107,
111,
114.5,
118,
122,
126,
130,
134.5,
138.5};
Double_t Graph_from_data_obs_rebin_fehy3002[44] = {
6.573787e-07,
6.292053e-07,
6.117274e-07,
1.22316e-05,
9.575083e-05,
8.094749e-05,
6.84397e-05,
5.766247e-05,
4.901194e-05,
4.137208e-05,
3.500149e-05,
2.951266e-05,
2.507521e-05,
2.130479e-05,
1.799366e-05,
1.522966e-05,
1.284541e-05,
1.088672e-05,
9.276611e-06,
7.60843e-06,
6.621505e-06,
5.412482e-06,
4.45283e-06,
3.977562e-06,
3.430724e-06,
2.873769e-06,
2.32068e-06,
1.953778e-06,
1.582365e-06,
1.378878e-06,
1.182038e-06,
1.027619e-06,
6.938164e-07,
8.35626e-07,
5.555851e-07,
5.097607e-07,
4.598297e-07,
3.533711e-07,
3.632828e-07,
2.586389e-07,
1.747793e-07,
1.694014e-07,
1.637337e-07,
1.59005e-07};
grae = new TGraphAsymmErrors(44,Graph_from_data_obs_rebin_fx3002,Graph_from_data_obs_rebin_fy3002,Graph_from_data_obs_rebin_felx3002,Graph_from_data_obs_rebin_fehx3002,Graph_from_data_obs_rebin_fely3002,Graph_from_data_obs_rebin_fehy3002);
grae->SetName("Graph_from_data_obs_rebin");
grae->SetTitle("");
grae->SetMarkerStyle(20);
grae->SetMarkerSize(0.9);
TH1F *Graph_Graph_from_data_obs_rebin3002 = new TH1F("Graph_Graph_from_data_obs_rebin3002","",100,584,8528);
Graph_Graph_from_data_obs_rebin3002->SetMinimum(6.249052e-08);
Graph_Graph_from_data_obs_rebin3002->SetMaximum(109998.9);
Graph_Graph_from_data_obs_rebin3002->SetDirectory(0);
Graph_Graph_from_data_obs_rebin3002->SetStats(0);
ci = TColor::GetColor("#000099");
Graph_Graph_from_data_obs_rebin3002->SetLineColor(ci);
Graph_Graph_from_data_obs_rebin3002->GetXaxis()->SetLabelFont(42);
Graph_Graph_from_data_obs_rebin3002->GetXaxis()->SetLabelSize(0.035);
Graph_Graph_from_data_obs_rebin3002->GetXaxis()->SetTitleSize(0.035);
Graph_Graph_from_data_obs_rebin3002->GetXaxis()->SetTitleFont(42);
Graph_Graph_from_data_obs_rebin3002->GetYaxis()->SetLabelFont(42);
Graph_Graph_from_data_obs_rebin3002->GetYaxis()->SetLabelSize(0.035);
Graph_Graph_from_data_obs_rebin3002->GetYaxis()->SetTitleSize(0.035);
Graph_Graph_from_data_obs_rebin3002->GetYaxis()->SetTitleFont(42);
Graph_Graph_from_data_obs_rebin3002->GetZaxis()->SetLabelFont(42);
Graph_Graph_from_data_obs_rebin3002->GetZaxis()->SetLabelSize(0.035);
Graph_Graph_from_data_obs_rebin3002->GetZaxis()->SetTitleSize(0.035);
Graph_Graph_from_data_obs_rebin3002->GetZaxis()->SetTitleFont(42);
grae->SetHistogram(Graph_Graph_from_data_obs_rebin3002);
grae->Draw("zp");
tex = new TLatex(0,10,"10^{4}");
tex->SetTextAlign(32);
tex->SetTextFont(42);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0,1,"10^{3}");
tex->SetTextAlign(32);
tex->SetTextFont(42);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0,0.1,"10^{2}");
tex->SetTextAlign(32);
tex->SetTextFont(42);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0,0.01,"10");
tex->SetTextAlign(32);
tex->SetTextFont(42);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0,0.001,"1");
tex->SetTextAlign(32);
tex->SetTextFont(42);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0,0.0001,"10^{#minus1}");
tex->SetTextAlign(32);
tex->SetTextFont(42);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0,1e-05,"10^{#minus2}");
tex->SetTextAlign(32);
tex->SetTextFont(42);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0,1e-06,"10^{#minus3}");
tex->SetTextAlign(32);
tex->SetTextFont(42);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0,1e-07,"10^{#minus4}");
tex->SetTextAlign(32);
tex->SetTextFont(42);
tex->SetLineWidth(2);
tex->Draw();
TGaxis *gaxis = new TGaxis(1246,2e-08,7866,2e-08,1246,7866,509,"BS");
gaxis->SetLabelOffset(1000);
gaxis->SetLabelSize(0.04);
gaxis->SetTickSize(0.03);
gaxis->SetGridLength(0);
gaxis->SetTitleOffset(1);
gaxis->SetTitleSize(0.04);
gaxis->SetTitleColor(1);
gaxis->SetTitleFont(62);
gaxis->SetMoreLogLabels();
gaxis->Draw();
c_1->Modified();
c->cd();
// ------------>Primitives in pad: c_2
TPad *c_2 = new TPad("c_2", "c_2",0.01,0.02,0.99,0.37);
c_2->Draw();
c_2->cd();
c_2->Range(2.91482,-7.269231,3.947382,3.5);
c_2->SetFillColor(0);
c_2->SetBorderMode(0);
c_2->SetBorderSize(2);
c_2->SetLogx();
c_2->SetGridx();
c_2->SetGridy();
c_2->SetLeftMargin(0.175);
c_2->SetRightMargin(0.05);
c_2->SetTopMargin(0);
c_2->SetBottomMargin(0.35);
c_2->SetFrameBorderMode(0);
c_2->SetFrameBorderMode(0);
Double_t xAxis2[45] = {1246, 1313, 1383, 1455, 1530, 1607, 1687, 1770, 1856, 1945, 2037, 2132, 2231, 2332, 2438, 2546, 2659, 2775, 2895, 3019, 3147, 3279, 3416, 3558, 3704, 3854, 4010, 4171, 4337, 4509, 4686, 4869, 5058, 5253, 5455, 5663, 5877, 6099, 6328, 6564, 6808, 7060, 7320, 7589, 7866};
TH1D *h_fit_residual_vs_mass2 = new TH1D("h_fit_residual_vs_mass2","h_fit_residual_vs_mass",44, xAxis2);
h_fit_residual_vs_mass2->SetBinContent(1,-2522.416);
h_fit_residual_vs_mass2->SetBinContent(2,-5065.52);
h_fit_residual_vs_mass2->SetBinContent(3,-8776.758);
h_fit_residual_vs_mass2->SetBinContent(4,-617.1423);
h_fit_residual_vs_mass2->SetBinContent(5,196.0867);
h_fit_residual_vs_mass2->SetBinContent(6,113.1183);
h_fit_residual_vs_mass2->SetBinContent(7,36.71953);
h_fit_residual_vs_mass2->SetBinContent(8,-26.43266);
h_fit_residual_vs_mass2->SetBinContent(9,-64.89191);
h_fit_residual_vs_mass2->SetBinContent(10,-83.89526);
h_fit_residual_vs_mass2->SetBinContent(11,-82.34386);
h_fit_residual_vs_mass2->SetBinContent(12,-66.64802);
h_fit_residual_vs_mass2->SetBinContent(13,-44.45266);
h_fit_residual_vs_mass2->SetBinContent(14,-18.79395);
h_fit_residual_vs_mass2->SetBinContent(15,-0.3495991);
h_fit_residual_vs_mass2->SetBinContent(16,15.83864);
h_fit_residual_vs_mass2->SetBinContent(17,25.04164);
h_fit_residual_vs_mass2->SetBinContent(18,30.6559);
h_fit_residual_vs_mass2->SetBinContent(19,33.0483);
h_fit_residual_vs_mass2->SetBinContent(20,30.9882);
h_fit_residual_vs_mass2->SetBinContent(21,30.51939);
h_fit_residual_vs_mass2->SetBinContent(22,26.95502);
h_fit_residual_vs_mass2->SetBinContent(23,23.61228);
h_fit_residual_vs_mass2->SetBinContent(24,22.27266);
h_fit_residual_vs_mass2->SetBinContent(25,19.92964);
h_fit_residual_vs_mass2->SetBinContent(26,17.38451);
h_fit_residual_vs_mass2->SetBinContent(27,14.38508);
h_fit_residual_vs_mass2->SetBinContent(28,12.40346);
h_fit_residual_vs_mass2->SetBinContent(29,10.26409);
h_fit_residual_vs_mass2->SetBinContent(30,9.11918);
h_fit_residual_vs_mass2->SetBinContent(31,7.974516);
h_fit_residual_vs_mass2->SetBinContent(32,7.059309);
h_fit_residual_vs_mass2->SetBinContent(33,4.579309);
h_fit_residual_vs_mass2->SetBinContent(34,6.003208);
h_fit_residual_vs_mass2->SetBinContent(35,3.75121);
h_fit_residual_vs_mass2->SetBinContent(36,3.47359);
h_fit_residual_vs_mass2->SetBinContent(37,3.164136);
h_fit_residual_vs_mass2->SetBinContent(38,2.20814);
h_fit_residual_vs_mass2->SetBinContent(39,2.354303);
h_fit_residual_vs_mass2->SetBinContent(40,0.8843693);
h_fit_residual_vs_mass2->SetBinContent(41,-1.306724);
h_fit_residual_vs_mass2->SetBinContent(42,-4.955041);
h_fit_residual_vs_mass2->SetBinContent(43,-26.83887);
h_fit_residual_vs_mass2->SetBinContent(44,-217.8978);
h_fit_residual_vs_mass2->SetBinError(1,1);
h_fit_residual_vs_mass2->SetBinError(2,1);
h_fit_residual_vs_mass2->SetBinError(3,1);
h_fit_residual_vs_mass2->SetBinError(4,1);
h_fit_residual_vs_mass2->SetBinError(5,1);
h_fit_residual_vs_mass2->SetBinError(6,1);
h_fit_residual_vs_mass2->SetBinError(7,1);
h_fit_residual_vs_mass2->SetBinError(8,1);
h_fit_residual_vs_mass2->SetBinError(9,1);
h_fit_residual_vs_mass2->SetBinError(10,1);
h_fit_residual_vs_mass2->SetBinError(11,1);
h_fit_residual_vs_mass2->SetBinError(12,1);
h_fit_residual_vs_mass2->SetBinError(13,1);
h_fit_residual_vs_mass2->SetBinError(14,1);
h_fit_residual_vs_mass2->SetBinError(15,1);
h_fit_residual_vs_mass2->SetBinError(16,1);
h_fit_residual_vs_mass2->SetBinError(17,1);
h_fit_residual_vs_mass2->SetBinError(18,1);
h_fit_residual_vs_mass2->SetBinError(19,1);
h_fit_residual_vs_mass2->SetBinError(20,1);
h_fit_residual_vs_mass2->SetBinError(21,1);
h_fit_residual_vs_mass2->SetBinError(22,1);
h_fit_residual_vs_mass2->SetBinError(23,1);
h_fit_residual_vs_mass2->SetBinError(24,1);
h_fit_residual_vs_mass2->SetBinError(25,1);
h_fit_residual_vs_mass2->SetBinError(26,1);
h_fit_residual_vs_mass2->SetBinError(27,1);
h_fit_residual_vs_mass2->SetBinError(28,1);
h_fit_residual_vs_mass2->SetBinError(29,1);
h_fit_residual_vs_mass2->SetBinError(30,1);
h_fit_residual_vs_mass2->SetBinError(31,1);
h_fit_residual_vs_mass2->SetBinError(32,1);
h_fit_residual_vs_mass2->SetBinError(33,1);
h_fit_residual_vs_mass2->SetBinError(34,1);
h_fit_residual_vs_mass2->SetBinError(35,1);
h_fit_residual_vs_mass2->SetBinError(36,1);
h_fit_residual_vs_mass2->SetBinError(37,1);
h_fit_residual_vs_mass2->SetBinError(38,1);
h_fit_residual_vs_mass2->SetBinError(39,1);
h_fit_residual_vs_mass2->SetBinError(40,1);
h_fit_residual_vs_mass2->SetBinError(41,1);
h_fit_residual_vs_mass2->SetBinError(42,1);
h_fit_residual_vs_mass2->SetBinError(43,1);
h_fit_residual_vs_mass2->SetBinError(44,1);
h_fit_residual_vs_mass2->SetMinimum(-3.5);
h_fit_residual_vs_mass2->SetMaximum(3.5);
h_fit_residual_vs_mass2->SetEntries(44);
h_fit_residual_vs_mass2->SetStats(0);
ci = TColor::GetColor("#ff0000");
h_fit_residual_vs_mass2->SetFillColor(ci);
h_fit_residual_vs_mass2->GetXaxis()->SetTitle("Dijet mass [TeV]");
h_fit_residual_vs_mass2->GetXaxis()->SetRange(1,44);
h_fit_residual_vs_mass2->GetXaxis()->SetMoreLogLabels();
h_fit_residual_vs_mass2->GetXaxis()->SetNoExponent();
h_fit_residual_vs_mass2->GetXaxis()->SetNdivisions(999);
h_fit_residual_vs_mass2->GetXaxis()->SetLabelFont(42);
h_fit_residual_vs_mass2->GetXaxis()->SetLabelOffset(1000);
h_fit_residual_vs_mass2->GetXaxis()->SetLabelSize(0.1);
h_fit_residual_vs_mass2->GetXaxis()->SetTitleSize(0.12);
h_fit_residual_vs_mass2->GetXaxis()->SetTitleFont(42);
h_fit_residual_vs_mass2->GetYaxis()->SetTitle("#frac{(Data-Fit)}{Uncertainty}");
h_fit_residual_vs_mass2->GetYaxis()->SetNdivisions(210);
h_fit_residual_vs_mass2->GetYaxis()->SetLabelFont(42);
h_fit_residual_vs_mass2->GetYaxis()->SetLabelSize(0.1);
h_fit_residual_vs_mass2->GetYaxis()->SetTitleSize(0.12);
h_fit_residual_vs_mass2->GetYaxis()->SetTitleOffset(0.6);
h_fit_residual_vs_mass2->GetYaxis()->SetTitleFont(42);
h_fit_residual_vs_mass2->GetZaxis()->SetLabelFont(42);
h_fit_residual_vs_mass2->GetZaxis()->SetLabelSize(0.035);
h_fit_residual_vs_mass2->GetZaxis()->SetTitleSize(0.035);
h_fit_residual_vs_mass2->GetZaxis()->SetTitleFont(42);
h_fit_residual_vs_mass2->Draw("hist");
tex = new TLatex(2000,-4,"2");
tex->SetTextAlign(22);
tex->SetTextFont(42);
tex->SetTextSize(0.1);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(3000,-4,"3");
tex->SetTextAlign(22);
tex->SetTextFont(42);
tex->SetTextSize(0.1);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(4000,-4,"4");
tex->SetTextAlign(22);
tex->SetTextFont(42);
tex->SetTextSize(0.1);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(5000,-4,"5");
tex->SetTextAlign(22);
tex->SetTextFont(42);
tex->SetTextSize(0.1);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(6000,-4,"6");
tex->SetTextAlign(22);
tex->SetTextFont(42);
tex->SetTextSize(0.1);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(7000,-4,"7");
tex->SetTextAlign(22);
tex->SetTextFont(42);
tex->SetTextSize(0.1);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(8000,-4,"8");
tex->SetTextAlign(22);
tex->SetTextFont(42);
tex->SetTextSize(0.1);
tex->SetLineWidth(2);
tex->Draw();
gaxis = new TGaxis(1246,-3.5,7866,-3.5,1246,7866,509,"BS");
gaxis->SetLabelOffset(1000);
gaxis->SetLabelSize(0.04);
gaxis->SetTickSize(0.03);
gaxis->SetGridLength(0);
gaxis->SetTitleOffset(1);
gaxis->SetTitleSize(0.04);
gaxis->SetTitleColor(1);
gaxis->SetTitleFont(62);
gaxis->SetMoreLogLabels();
gaxis->Draw();
c_2->Modified();
c->cd();
c->Modified();
c->cd();
c->SetSelected(c);
}
|
/** test1i.c --- Init module for test 1.
Christopher League
Test 1 just loads a module, starts it, and closes it.
Both modules say hello, and that's about it.
It also tests Get_char, Kmalloc, and Kfree system calls.
**/
#include "io412.h"
#include "klib.h"
/** Local prototypes, etc. */
typedef int (*PROCPTR)( int, char** );
/** Arguments for children */
int child_argc = 2;
char* child_argv[] = {"test1a", "what a nice day"};
/***
*** Entry point
***/
int Proc( int argc, char** argv )
{
PROCPTR p;
int pid;
char c;
Cprintf( "test1i: Hello!\n" );
Cprintf( "test1i: [Loading test1a...]\n" );
p = Load_module( "test1a.mod" );
Cprintf( "test1i: proc == %p\n", p );
Cprintf( "test1i: [Starting test1a...]\n" );
pid = Proc_start( p, child_argc, child_argv );
Cprintf( "test1i: pid == %d\n", pid );
Cprintf( "test1i: [Closing test1a...]\n" );
Close_module( "test1a.mod" );
Cprintf( "test1i: [Sleeping until keypress...]\n" );
c = Get_char();
Cprintf( "test1i: c == '%c'\n", c );
Cprintf( "test1i: [Terminating...]\n" );
return 0;
}
|
#include <apue.h>
Sigfunc * signal_intr (int signo, Sigfunc *func)
{
struct sigaction act, oact;
act.sa_handler = func;
sigemptyset (&act.sa_mask);
act.sa_flags = 0;
#ifdef SA_INTERRUPT
act.sa_flags |= SA_INTERRUPT;
#endif
if (sigaction (signo, &act, &oact) < 0)
return (SIG_ERR);
return (oact.sa_handler);
}
|
#include <swamp.h>
#include <std.h>
inherit MONSTER;
int wraithgo();
void create() {
::create();
set_name("bog wraith");
set_short("bog wraith");
set_long("Shadowy creatures that haunt the swamp, bog wraiths stand nearly
seven feet tall and wear rotting black robes. They have blood red eyes which
are the only distinguishable facial feature of the wraith.");
set("aggressive", 50);
set_id(({"bog wraith", "wraith"}));
set_class("mage");
set_subclass("sorceror");
set_alignment(-800);
set_skill("psionics", 200);
set_skill("conjuring", 200);
set_skill("healing", 200);
set_stats("intelligence", 100);
set_race("wraith");
set_body_type("human");
if(random(10) > 2) set_gender("male"); else set_gender("female");
set_spell_chance(35);
set_spells(({"solidify", "dissolve", "psistorm", "psidrain"}));
set_level(50);
set_property("no corpse", 1);
set_die("The wraith vanishes!");
}
int wraithgo() {
tell_room(environment(this_object()),"The wraith vanishes!", ({ }));
this_object()->remove();
return 1;
}
|
#include <std.h>
#include <saahr.h>
inherit HOUSE_ROOM;
void create() {
::create();
set_properties(([
"light":2,
"night light":1,
"indoors":0,
"town":1
]));
set_short("a small town");
set_long(
"The river flows nearby beneath a tall willow tree. A small cottage "
"sits in a bed of flowers. The path through this corner of the village "
"loops around from the north to the west."
);
set_items(([
"river" : "A clear river flows to the south.",
({ "tree", "willow", "willow tree" }) :
"The willow tree is very large and droopy. Its small leaves cover "
"a lot of the ground.",
"cottage" : "The cottage is very humble. Its stained wooden exterior "
"looks well worn by time and the elements.",
"flowers" : "Small yellow and white flowers.",
"path" : "The path is very small and seems rarely used.",
]));
set_smell( ({ "default", "flowers" }),
"A light, sweet scent is released by the flowers.");
set_exits(([
"north":VPROOMS"town14_8",
"northeast":VPROOMS"town15_8",
"west":VPROOMS"town13_9",
"enter house":VPROOMS"house14_9"
]));
check_door();
}
|
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <netdb.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <ctype.h>
#include <string.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <semaphore.h>
/*struct sockaddr_in {
short sin_family; // e.g. AF_INET
unsigned short sin_port; // e.g. htons(3490)
struct in_addr sin_addr; // see struct in_addr, below
char sin_zero[8]; // zero this if you want to
};
struct in_addr {
unsigned long s_addr; // load with inet_aton()
};*/
int main(){
/*char *link;
printf("link: ");
read(0,*link,sizeof(link))
*/
int fd, fdcliente, leido, conectado, connfd, pid;
char buff[1000];
struct sockaddr_in procrem={};
fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0 ){
perror ("socket");
return -1;
}
procrem.sin_family = AF_INET;
procrem.sin_port = htons(8080);
//procrem.sin_addr = 192.168.1.52;
procrem.sin_addr.s_addr = htonl(INADDR_ANY);
//inet_pton(AF_INET,"0.0.0.0", &procrem.sin_addr);
int a = 1;
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,&a, sizeof a);
if (bind(fd,(struct sockaddr *)&procrem, sizeof procrem) < 0 ) {
perror ("bind");
return -1;
}
listen(fd, 5);
signal(SIGCHLD,SIG_IGN ); //para sacar procesos terminados de la PCB ...
while ( (connfd = accept(fd,NULL, 0)) > 0 ){
pid = fork();
//hijo
if ( pid == 0 ) {
char *p1=NULL,*p2=NULL,*url=NULL,*ancla=NULL,*nuevo_ancla=NULL;
int largo_ancla=0,tam_url=0,tam_ancla=0,tam_oracion=0;
leido = read (connfd,buff ,sizeof buff);
write (1 ,buff ,leido);
char *link=NULL,*ptr=NULL,*palabra_reservada=NULL;
ptr = strtok(buff,"-");
link=ptr;
if((ptr = strtok(NULL,"")) != NULL){
palabra_reservada=ptr;
}
printf("\nlink ->> %s\n",link);
printf("palabra ->> %s\n",palabra_reservada);
p1="http:";
p2="https:";
ptr = strtok(link,"/");
if((strcmp(ptr,p2)==0) || (strcmp(ptr,p1)==0)){
ptr = strtok(NULL,"/");
url=ptr;
printf("url -> %s\n",url);
} else {
url=ptr;
printf("url -> %s\n",url);
}
nuevo_ancla="";
if((ptr = strtok(NULL,"")) != NULL){
ancla=ptr;
largo_ancla=strlen(ancla);
//char nuevo_ancla[largo_ancla+1];
for(int i=0; i<=largo_ancla;i++){
if(i==0){
nuevo_ancla[0]='/';
}else{
nuevo_ancla[i]=ancla[i-1];
}
}
printf("ancla-> %s \n",nuevo_ancla);
tam_ancla=strlen(nuevo_ancla);
}
tam_url=strlen(url);
printf("ancla-> %s \n",nuevo_ancla);
printf("tam url: %d\n",tam_url);
printf("tam ancla: %d\n",tam_ancla);
tam_oracion=40+tam_url+tam_ancla;
char oracion[tam_oracion];
printf("tam oracion: %d\n",tam_oracion);
char part1[]="GET ";
char part2[]=" HTTP/1.1\nHost: ";
char part3[]="\nConnection: close\n\n";
strcpy(oracion,part1);
strcat(oracion,nuevo_ancla);
strcat(oracion,part2);
strcat(oracion,url);
strcat(oracion,part3);
printf("oracion:\n%s \n",oracion);
printf("-----------------\n");
printf("GET /es/ua/fi.html HTTP/1.1\nHost: www.um.edu.ar\nConnection: close\n\n");
//write (connfd ,buff ,leido);
// se conecta como cliente a un servidor http
struct sockaddr_in serverhttp={};
fdcliente = socket(AF_INET, SOCK_STREAM, 0);
if (fdcliente < 0 ){
perror ("socketcliente");
return -1;
}
serverhttp.sin_family = AF_INET;
serverhttp.sin_port = htons(80); //puerto default servidor http
//procrem.sin_addr = 192.168.1.52;
//procrem.sin_addr.s_addr = htonl(0xc0a80134);
//inet_pton(AF_INET,"www.um.eud.ar", &procrem.sin_addr
struct hostent *hp = gethostbyname(url);
if(hp==NULL){
printf("gethostmyname() failed\n");
return 1;
}
inet_pton(AF_INET,inet_ntoa( *( struct in_addr*)( hp -> h_addr_list[0])), &serverhttp.sin_addr);
conectado = connect(fdcliente,(struct sockaddr *)&serverhttp, sizeof serverhttp);
if (conectado < 0 ){
perror ("connect");
return -1;
}
write(fdcliente, "GET /es/ua/fi.html HTTP/1.1\nHost: www.um.edu.ar\nConnection: close\n\n", 67);
while ((leido = read(fdcliente, buff , sizeof buff)) > 0){
if (leido < 0 ){
perror ("read");
return -1;
}
write(connfd,buff,leido);
//parsear palabra
}
return 0;
}
close(connfd);
}
return 0;
}
|
/*
* File: ScreenMasterCommandList.h
* Author: fascio
*
* Created on December 17th, 2014, 19:03
*/
#ifndef __SCREEN_MASTER_COMMAND_LIST_H__
#define __SCREEN_MASTER_COMMAND_LIST_H__
#include "ScreenDisplayDeviceCommandList.h"
//****************************************************************************************
//* COMMAND ID LIST FOR SCREEN MASTER PROTOCOL DEVICE
//****************************************************************************************
#define SCREEN_MASTER_DEVICE_CLIENT_BASE (7000)
#define SCREEN_MASTER_DEVICE_SERVER_BASE (8000)
#define SCREEN_MASTER_DEVICE_SERVER_ERROR_CODE_COMMAND_ID (SCREEN_MASTER_DEVICE_SERVER_BASE + 1)
/*
//****************************************************************************************
//* COMMAND ID FOR SCREEN DISPLAY DEVICE
//****************************************************************************************
#define SCREEN_MASTER_DEVICE_CLIENT_CMD_ID_DSPY_FLOAT_VALUE_UPDATE (SCREEN_MASTER_DEVICE_CLIENT_BASE | 2)
#define SCREEN_MASTER_DEVICE_SERVER_CMD_ID_DSPY_FLOAT_VALUE_UPDATE (SCREEN_MASTER_DEVICE_SERVER_BASE | 2)
//****************************************************************************************
//* COMMAND ID FOR DOT MATRIX DEVICE
//****************************************************************************************
#define SCREEN_MASTER_DEVICE_CLIENT_CMD_ID_DOT_MATRIX_SEND_TEXT (SCREEN_MASTER_DEVICE_CLIENT_BASE | 3)
#define SCREEN_MASTER_DEVICE_SERVER_CMD_ID_DOT_MATRIX_SEND_TEXT (SCREEN_MASTER_DEVICE_SERVER_BASE | 3)
#define SCREEN_MASTER_DEVICE_CLIENT_CMD_ID_DOT_MATRIX_SEND_TEXT_DELAY (SCREEN_MASTER_DEVICE_CLIENT_BASE | 4)
#define SCREEN_MASTER_DEVICE_SERVER_CMD_ID_DOT_MATRIX_SEND_TEXT_DELAY (SCREEN_MASTER_DEVICE_SERVER_BASE | 4)
*/
#endif /* __SCREEN_MASTER_COMMAND_LIST_H__ */
|
/*
* buffer_functions.c
*
* Created on: 11-Nov-2019
* Author: Hp
*/
#include <buffer_functions.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
#include <fsl_debug_console.h>
uint8_t rw;
enum Error_status result;
/* Function to create buffer */
// Pass a storage buffer and size
enum Error_status create_buffer(uint16_t *buffer_t,user_n *user_t,uint16_t *size)
{
if(*size>0)
{
buffer_t = (uint16_t *)malloc(*size *sizeof(uint16_t));
if(buffer_t!=NULL)
{
result = SUCCESS;
user_t->buffer = buffer_t;
user_t->head = buffer_t;
user_t->tail = buffer_t;
user_t->maxlen = *size;
// PRINTF("\n\rmaxlen = %d\n\r",user_t->maxlen);
//PRINTF("user_t.head = %p\n\r",user_t->head);
// PRINTF("\n\rlast value = %p\n\r",(user_t->buffer + (user_t->maxlen-1)));
}
else
{
PRINTF("\n\rBUFFER NOT ALLOCATED\n\r");
result = FAILURE;
}
}
else
{
PRINTF("\n\rEnter size greater than 0\n\r");
result = FAILURE;
}
// user_t.maxlen = size;
//return (int)buffer_t;
return result;
}
/* Reallocate Buffer */
// Function called when original buffer becomes full
enum Error_status overflow_handler(uint16_t *buffer_old,user_n *user_t,uint16_t size)
{
size = size + 10;
if(size>0)
{
//uint16_t *buffer_rt = (uint16_t *)malloc(*size*sizeof(uint16_t));
uint16_t *buffer_rt = (uint16_t *)realloc(buffer_old,(unsigned int)size*sizeof(uint8_t));
// PRINTF("\n\rrealloc address = %p\n\r",buffer_rt);
//(user_t->buffer,*size*sizeof(uint16_t));
if(buffer_rt!=NULL)
{
result = SUCCESS;
user_t->buffer = buffer_rt;
// Head+last position
// PRINTF("\n\rhead_count = %d\n\r",user_t->head_count);
user_t->head = buffer_rt;
user_t->head = user_t->head + user_t->head_count;
user_t->tail = buffer_rt;
user_t->tail = user_t->tail + user_t->tail_count;
user_t->maxlen = size;
// PRINTF("\n\rmaxlen = %d\n\r",user_t->maxlen);
// PRINTF("user_t.head = %p\n\r",user_t->head);
// PRINTF("\n\rlast value = %p\n\r",(user_t->buffer + (user_t->maxlen-1)));
}
else
{
PRINTF("\n\rBUFFER NOT REALLOCATED\n\r");
result = FAILURE;
}
}
else
{
PRINTF("\n\rEnter size greater than 0\n\r");
result = FAILURE;
}
// user_t.maxlen = size;
//return (int)buffer_t;
return result;
}
/*Buffer full Function*/
// Checks if buffer is full
bool buffer_full(user_n *user_t)
{
return user_t->full;
}
/*Buffer Empty Function*/
// Checks if buffer is empty
// Returns a false when empty
bool buffer_empty(user_n *user_t)
{
//PRINTF("\n\rhead = %x\n\r",user_t->head);
//PRINTF("\n\rtail = %x\n\r",user_t->tail);
//PRINTF("\n\rfull = %d\n\r",user_t->full);
//PRINTF("\n\rEMPTY = %d\n\r",((!user_t->full) && (user_t->head==user_t->tail)));
return ((!user_t->full) && (user_t->head==user_t->tail));
}
/* Dummy write to buffer (using SCANF) */
// Write to the head address and advance the head location
// If the buffer is full we need to advance our tail pointer as well as head
// increment head while writing
/* Reset Buffer */
// Set the structure elements to 0
// put head==tail
void buffer_reset(user_n *user_t)
{
user_t->head = user_t->buffer;
user_t->tail = user_t->buffer;
user_t->full = false;
}
/* Destroy Buffer */
// call free on the buffer address
void buffer_destroy(user_n *user_t)
{
free(user_t->buffer);
}
/* Advance Pointer */
// PASS TAIL and HEAD
void advance_pointer(user_n *user_t)
{
if(user_t->full)
{
user_t->tail++;
user_t->tail_count++;
if(user_t->tail == ((user_t->buffer+user_t->maxlen)))
{
user_t->tail = user_t->buffer;
//user_t->tail_count = 0;
}
}
//user_t->head = (user_t->head+1);
user_t->head++;
user_t->head_count++;
if(user_t->head == ((user_t->buffer+user_t->maxlen)))
{
// PRINTF("\n\rRollover head = %p\n\r",user_t->head);
user_t->head = user_t->buffer;
//user_t->head_count = 0;
}
user_t->full=(user_t->head==user_t->tail);
}
/* Retreat Pointer */
// PASS TAIL
void retreat_pointer(user_n *user_t)
{
user_t->full = false;
user_t->tail++;
user_t->tail_count++;
if(user_t->tail == ((user_t->buffer+user_t->maxlen)))
{
user_t->tail = user_t->buffer;
//user_t->tail_count = 0;
}
}
/* Size function */
// PASS HEAD and TAIL
//int cbuf_size(user_n *user_t)
//{
// if(user_t->head>=user_t->tail)
// {
//
// user_t->count = user_t->head - user_t->tail;
// }
// else
// {
// user_t->count = ((user_t->maxlen + user_t->head)-user_t->tail);
// }
//
// return user_t->count;
//}
int character_count(user_n *user_t)
{
// rw == 1 while writing
// rw == 0 while reading
if(rw == 1)
{
user_t->count++;
}
else if(rw == 0)
{
user_t->count--;
}
// PRINTF("\n\rcount = %d\n\r",user_t->count);
return user_t->count;
}
/* Read from buffer */
// Increment tail while writing
int buffer_read(user_n *user_t, uint8_t readdata)
{
readdata = *(user_t->tail);
retreat_pointer(user_t);
//PRINTF("\n\rreaddata = %d, tail = %d\n\r",readdata,*(user_t->tail));
//PRINTF("\n\rREAD ADDRESS = %p\n\r",user_t->tail);
rw = 0;
character_count(user_t);
if(buffer_empty(user_t))
{
//PRINTF("\n\rBUFFER IS EMPTY!\n\r");
user_t->tail = user_t->buffer;
}
return readdata;
}
/* Write to buffer */
// Write to the head address and advance the head location
// If the buffer is full we need to advance our tail pointer as well as head
// increment head while writing
void buffer_write(uint16_t *pointer,user_n *user_t, uint32_t writedata, uint16_t size,uint8_t *flag)
{
buffer_full(user_t);
*(user_t->head) = writedata;
//PRINTF("\n\r data at head = %d\n\r",*(user_t->head));
//PRINTF("\n\r head address = %p\n\r",user_t->head);
advance_pointer(user_t);
//cbuf_size(user_t);
rw = 1;
character_count(user_t);
if(buffer_full(user_t))
{
user_t->full = false;
// PRINTF("\n\rBUFFER IS FULL!\n\r");
*flag = 1;
// Reallocate function
//overflow_handler(pointer,user_t,size);
//buffer_destroy(user_t);
}
if(buffer_empty(user_t))
{
// PRINTF("\n\rBUFFER IS EMPTY!\n\r");
}
}
|
//FASE DI DISCESA PARACADUTALE E ATTERRAGGIO
#pragma once
#ifndef DISCESA_BASSA_H
#define DISCESA_BASSA_H
#include "Utilita_Librerie.h"
extern STR_Sistema Sistema;
extern STR_Telemetria Telemetria;
extern STR_Sensori Sensori;
void do_DiscesaBassa();
#endif
|
/*
****************************************************************
* *
* mkdir.c *
* *
* Gerenciador de arquivos *
* *
* Versão 4.5.0, de 17.10.03 *
* 4.5.0, de 17.10.03 *
* *
* Módulo: xfm *
* Utilitários Básicos *
* Categoria B *
* *
* TROPIX: Sistema Operacional Tempo-Real Multiprocessado *
* Copyright © 2003 NCE/UFRJ - tecle "man licença" *
* *
****************************************************************
*/
#include <sys/types.h>
#include <sys/syscall.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stat.h>
#include <X11/Intrinsic.h>
#include "../h/xfm.h"
/*
****************************************************************
* Variáveis e Definições globais *
****************************************************************
*/
/*
****** Protótipos de funções ***********************************
*/
void mkdir_1 (void);
/*
****************************************************************
* Verifica se é permitida a criação de um diretório *
****************************************************************
*/
int
permission_mkdir (const NODE *np)
{
if (np == NONODE)
return (-1);
if (!S_ISDIR (np->n_s.st_mode))
return (-1);
return (1);
} /* end permission_mkdir */
/*
****************************************************************
* Cria um novo diretório *
****************************************************************
*/
void
mkdir_0 (void)
{
const WINDATA *menu_wp;
WINDATA *wp = &nm_edit;
KEYDATA *kp = &keydata;
int len = 50;
XWindowChanges value;
/*
* Prepara o tamanho da janela
*/
switch (present_menu)
{
case TREE_MENU:
menu_wp = &tree_menu;
break;
case DIR_MENU:
menu_wp = &dir_menu;
break;
default:
return;
}
value.width = wp->width = 2 * (MENU_BORDER + SHADOW) + len * wp->font_width;
value.height = wp->height = 2 * (MENU_BORDER + SHADOW) + wp->font_height;
value.x = menu_wp->x + menu_wp->width;
value.y = menu_wp->y + menu_wp->height - 2 * (wp->font_height + 2 * SHADOW);
XConfigureWindow (display, wp->win, CWWidth|CWHeight|CWX|CWY, &value);
/*
* Prepara a área de leitura do nome do diretório
*/
kp->k_code = 'M';
kp->k_changed = 0;
kp->k_display = display;
kp->k_win = wp->win;
kp->k_gc = wp->text_gc;
kp->k_rev_gc = reverse_text_gc;
kp->k_font_width = wp->font_width;
kp->k_area = edit_area;
kp->k_count = 0;
kp->k_offset = 0;
kp->k_size = sizeof (edit_area);
kp->k_x = MENU_BORDER + SHADOW;
kp->k_y = MENU_BORDER + 1 * (wp->font_height + 2 * SHADOW) - (wp->font_descent + SHADOW);
kp->k_function = mkdir_1;
kp->k_area[0] = '\0';
XMapWindow (display, wp->win);
} /* end mkdir_0 */
/*
****************************************************************
* Cria o diretório, após ter teclado o nome *
****************************************************************
*/
void
mkdir_1 (void)
{
const MENUDATA *mp = &menudata[present_menu];
const WINDATA *wp = &nm_edit;
NODE *np, *pp = mp->menu_node;
/*
* Prólogo
*/
XUnmapWindow (display, wp->win);
XUnmapWindow (display, mp->windata->win);
/*
* Cria o novo nó
*/
np = create_new_node (pp, edit_area, strlen (edit_area));
/*
* Tenta criar o diretório
*/
if (mkdir (np->n_path, 0755) < 0)
{
bad:
draw_error_msg_text ("*Não consegui criar o diretório \"%s\"", np->n_path);
free (np); return;
}
/*
* Obtém os estados
*/
if (lstat (np->n_path, &np->n_ls) < 0)
{ rmdir (np->n_path); goto bad; }
memmove (&np->n_s, &np->n_ls, sizeof (STAT));
np->n_sb_flags = get_mount_flags (np->n_ls.st_dev);
/*
* Insere na lista
*/
insert_node_lexicografically (pp, np); /* Já incrementa "n_line_size" */
pp->n_ls.st_nlink += 1; /* O diretório pai tem mais um filho */
pp->n_s.st_nlink += 1;
/*
* Verifica se redesenha a árvore
*/
if (pp->n_ls.st_nlink == 3 || pp->n_expanded)
{
XClearWindow (display, tree.win);
draw_tree_win ();
}
/*
* Verifica se redesenha o diretório
*/
if (pp == dir_win_node)
{
XClearWindow (display, dir.win);
draw_dir_win ();
}
/*
* Mensagem final
*/
draw_msg_text ("Criado o Diretório \"%s\"", np->n_path);
} /* end mkdir_1 */
|
00010000020004d7
*/
/* inherited classes
#ifndef _OZ00010000020004d1P_H_
#define _OZ00010000020004d1P_H_
#define OZClassPart0001000002fffffd_0_in_00010000020004d1 1
#define OZClassPart0001000002fffffe_0_in_00010000020004d1 1
#define OZClassPart00010000020004d6_0_in_00010000020004d1 -1
#define OZClassPart00010000020004d7_0_in_00010000020004d1 -1
#define OZClassPart00010000020004d1_0_in_00010000020004d1 0
#endif _OZ00010000020004d1P_H_
|
/**
greedy
ayadi mohammed
ayadi.mohamed@outlook.com
**/
#include <stdio.h>
#include <cs50.h>
#include <math.h>
#define QUARTER 25
#define DIME 10
#define NICKEL 5
#define PENNY 1
//prototypes
float getUserAmount(void);
int main(void)
{
float amount = getUserAmount();
int cents = round(amount * 100),count_Nbr = 0;
//printf("first cent : %i \n",cents);
while(cents>0)
{
if(cents >= QUARTER) {
count_Nbr += cents / QUARTER;
cents -= QUARTER *(cents / QUARTER);
}
else if(cents >= DIME) {
count_Nbr += cents / DIME ;
cents -= DIME * (cents / DIME);
}
else if(cents >= NICKEL) {
count_Nbr += cents / NICKEL ;
cents -= NICKEL * (cents / NICKEL);
}
else if(cents >= PENNY) {
count_Nbr += cents / PENNY ;
cents -= PENNY * (cents / PENNY);
}
}
printf("%d\n",count_Nbr);
return 0;
}
float getUserAmount(){
float amount = 0;
do{
//prompt user for amount of change
printf("hai! How much change is owed ? : ");
amount = GetFloat();
}while(amount<0.0);
return amount;
}
|
#ifndef _SAMPLE_FUNCTIONS
#define _SAMPLE_FUNCTIONS
void looping_func(void);
long int returning_func(void);
#endif
|
#include<stdio.h>
#include<conio.h>
struct process
{
char name;
int at,bt,ct,wt,tt;
int completed;
float ntt;
}p[10];
int n;
void sortByArrival()
{
struct process temp;
int i,j;
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
if(p[i].at>p[j].at)
{
temp=p[i];
p[i]=p[j];
p[j]=temp;
}
}
}
}
void main()
{
int i,j,time,sum_bt=0;
char c;
float avgwt=0;
clrscr();
printf("Enter no of processes:");
scanf("%d",&n);
for(i=0,c='A';i<n;i++,c++)
{
p[i].name=c;
printf("\nEnter the arrival time and burst time of process %c: ",p[i].name);
scanf("%d%d",&p[i].at,&p[i].bt);
p[i].completed=0;
sum_bt+=p[i].bt;
}
sortByArrival();
printf("\nName\tArrivalTime\tBurstTime\tWaitingTime\tTurnAroundTime\tRR";
for(time=p[0].at;time<sum_bt;)
{
float hrr=-9999;
int loc;
for(i=0;i<n;i++)
{
if(p[i].at<=time && p[i].completed!=1)
{
float temp=(p[i].bt + (time-p[i].at))/p[i].bt;
if(hrr < temp)
{
hrr=temp;
loc=i;
}
}
}
time+=p[loc].bt;
p[loc].wt=time-p[loc].at-p[loc].bt;
p[loc].tt=time-p[loc].at;
p[loc].ntt=((float)p[loc].tt/p[loc].bt);
p[loc].completed=1;
avgwt+=p[loc].wt;
printf("\n%c\t\t%d\t\t%d\t\t%d\t\t%d\t%f",p[loc].name,p[loc].at,p[loc].bt,p[lo
.wt,p[loc].tt,p[loc].ntt);
}
printf("\nAverage waiting time:%f\n",avgwt/n);
getch();
}
|
/* Generated by re2c 1.1.1 */
/* scanner.re
*
* This file is part of the Phalcon Framework.
*
* (c) Phalcon Team <team@phalcon.io>
*
* For the full copyright and license information, please view the
* LICENSE.txt file that was distributed with this source code.
*/
#include "php_phalcon.h"
#include "scanner.h"
/* for re2c */
#define VVCTYPE unsigned char
#define VVCURSOR (s->start)
#define VVLIMIT (s->end)
#define VVMARKER (s->marker)
void phvolt_rtrim(phvolt_scanner_token *token) {
char *cursor, *removed_str;
int i;
char ch;
if (token->len > 0) {
cursor = token->value;
cursor += (token->len - 1);
for (i = token->len; i > 0; i--) {
ch = (*cursor);
if (ch == '\t' || ch == '\n' || ch == '\r' || ch == ' ' || ch == '\v') {
cursor--;
continue;
}
break;
}
if (i >= 0) {
removed_str = emalloc(i + 1);
memcpy(removed_str, token->value, i);
removed_str[i] = '\0';
efree(token->value);
token->value = removed_str;
token->len = i;
}
}
}
void phvolt_ltrim(phvolt_scanner_token *token) {
char *cursor, *removed_str;
int i;
if (token->len > 0) {
cursor = token->value;
for (i = 0; i < token->len; i++) {
char ch = (*cursor);
if (ch == '\t' || ch == '\n' || ch == '\r' || ch == ' ' || ch == '\v') {
cursor++;
continue;
}
break;
}
if (i >= 0) {
removed_str = emalloc(token->len - i + 1);
memcpy(removed_str, token->value + i, token->len - i);
removed_str[token->len - i] = '\0';
efree(token->value);
token->value = removed_str;
token->len = token->len - i;
}
}
}
int phvolt_get_token(phvolt_scanner_state *s, phvolt_scanner_token *token) {
unsigned char next, double_next;
char *start = VVCURSOR;
int status = PHVOLT_SCANNER_RETCODE_IMPOSSIBLE;
while (PHVOLT_SCANNER_RETCODE_IMPOSSIBLE == status) {
if (s->mode == PHVOLT_MODE_RAW || s->mode == PHVOLT_MODE_COMMENT) {
next = '\0';
double_next = '\0';
if (*VVCURSOR == '\n') {
s->active_line++;
}
if (*VVCURSOR != '\0') {
next = *(VVCURSOR + 1);
if (next != '\0') {
double_next = *(VVCURSOR + 2);
}
}
if (*VVCURSOR == '\0' || (*VVCURSOR == '{' && (next == '%' || next == '{' || next == '#'))) {
if (next != '#') {
s->mode = PHVOLT_MODE_CODE;
if (s->raw_buffer_cursor > 0) {
token->opcode = PHVOLT_T_RAW_FRAGMENT;
token->value = emalloc(sizeof(char) * s->raw_buffer_cursor + 1);
memcpy(token->value, s->raw_buffer, s->raw_buffer_cursor);
token->value[s->raw_buffer_cursor] = 0;
token->len = s->raw_buffer_cursor;
if (s->whitespace_control == 1) {
phvolt_ltrim(token);
s->whitespace_control = 0;
}
if (double_next == '-') {
phvolt_rtrim(token);
}
s->raw_buffer_cursor = 0;
} else {
token->opcode = PHVOLT_T_IGNORE;
}
} else {
while ((next = *(++VVCURSOR))) {
if (next == '#' && *(VVCURSOR + 1) == '}') {
VVCURSOR += 2;
token->opcode = PHVOLT_T_IGNORE;
return 0;
} else {
if (next == '\n') {
s->active_line++;
}
}
}
return PHVOLT_SCANNER_RETCODE_EOF;
}
return 0;
} else {
if (s->raw_buffer_cursor == s->raw_buffer_size) {
s->raw_buffer_size += PHVOLT_RAW_BUFFER_SIZE;
s->raw_buffer = erealloc(s->raw_buffer, s->raw_buffer_size);
}
memcpy(s->raw_buffer+s->raw_buffer_cursor, VVCURSOR, 1);
s->raw_buffer_cursor++;
++VVCURSOR;
}
} else {
{
VVCTYPE vvch;
unsigned int vvaccept = 0;
vvch = *VVCURSOR;
switch (vvch) {
case 0x00: goto vv2;
case '\t':
case '\r':
case ' ': goto vv6;
case '\n': goto vv9;
case '!': goto vv11;
case '"': goto vv13;
case '%': goto vv14;
case '\'': goto vv16;
case '(': goto vv17;
case ')': goto vv19;
case '*': goto vv21;
case '+': goto vv23;
case ',': goto vv25;
case '-': goto vv27;
case '.': goto vv29;
case '/': goto vv31;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9': goto vv33;
case ':': goto vv36;
case '<': goto vv38;
case '=': goto vv40;
case '>': goto vv42;
case '?': goto vv44;
case 'A':
case 'a': goto vv46;
case 'B':
case 'b': goto vv48;
case 'C':
case 'c': goto vv49;
case 'D':
case 'd': goto vv50;
case 'E':
case 'e': goto vv51;
case 'F':
case 'f': goto vv52;
case 'G':
case 'H':
case 'J':
case 'K':
case 'L':
case 'P':
case 'Q':
case 'U':
case 'V':
case 'X':
case 'Y':
case 'Z':
case '_':
case 'g':
case 'h':
case 'j':
case 'k':
case 'l':
case 'p':
case 'q':
case 'u':
case 'v':
case 'x':
case 'y':
case 'z': goto vv53;
case 'I': goto vv55;
case 'M':
case 'm': goto vv56;
case 'N':
case 'n': goto vv57;
case 'O':
case 'o': goto vv58;
case 'R':
case 'r': goto vv59;
case 'S':
case 's': goto vv60;
case 'T':
case 't': goto vv61;
case 'W':
case 'w': goto vv62;
case '[': goto vv63;
case '\\': goto vv65;
case ']': goto vv66;
case 'i': goto vv68;
case '{': goto vv69;
case '|': goto vv71;
case '}': goto vv73;
case '~': goto vv75;
default: goto vv4;
}
vv2:
++VVCURSOR;
{
status = PHVOLT_SCANNER_RETCODE_EOF;
break;
}
vv4:
++VVCURSOR;
vv5:
{
status = PHVOLT_SCANNER_RETCODE_ERR;
break;
}
vv6:
vvch = *++VVCURSOR;
switch (vvch) {
case '\t':
case '\r':
case ' ': goto vv6;
default: goto vv8;
}
vv8:
{
token->opcode = PHVOLT_T_IGNORE;
return 0;
}
vv9:
++VVCURSOR;
{
s->active_line++;
token->opcode = PHVOLT_T_IGNORE;
return 0;
}
vv11:
vvch = *++VVCURSOR;
switch (vvch) {
case '=': goto vv77;
default: goto vv12;
}
vv12:
{
token->opcode = PHVOLT_T_NOT;
return 0;
}
vv13:
vvaccept = 0;
vvch = *(VVMARKER = ++VVCURSOR);
if (vvch <= 0x00) goto vv5;
goto vv80;
vv14:
vvch = *++VVCURSOR;
switch (vvch) {
case '}': goto vv85;
default: goto vv15;
}
vv15:
{
token->opcode = PHVOLT_T_MOD;
return 0;
}
vv16:
vvaccept = 0;
vvch = *(VVMARKER = ++VVCURSOR);
if (vvch <= 0x00) goto vv5;
goto vv88;
vv17:
++VVCURSOR;
{
token->opcode = PHVOLT_T_PARENTHESES_OPEN;
return 0;
}
vv19:
++VVCURSOR;
{
token->opcode = PHVOLT_T_PARENTHESES_CLOSE;
return 0;
}
vv21:
vvch = *++VVCURSOR;
switch (vvch) {
case '=': goto vv90;
default: goto vv22;
}
vv22:
{
token->opcode = PHVOLT_T_MUL;
return 0;
}
vv23:
vvch = *++VVCURSOR;
switch (vvch) {
case '+': goto vv92;
case '=': goto vv94;
default: goto vv24;
}
vv24:
{
token->opcode = PHVOLT_T_ADD;
return 0;
}
vv25:
++VVCURSOR;
{
token->opcode = PHVOLT_T_COMMA;
return 0;
}
vv27:
vvaccept = 1;
vvch = *(VVMARKER = ++VVCURSOR);
switch (vvch) {
case '%': goto vv96;
case '-': goto vv97;
case '=': goto vv99;
case '}': goto vv101;
default: goto vv28;
}
vv28:
{
token->opcode = PHVOLT_T_SUB;
return 0;
}
vv29:
vvch = *++VVCURSOR;
switch (vvch) {
case '.': goto vv102;
default: goto vv30;
}
vv30:
{
token->opcode = PHVOLT_T_DOT;
return 0;
}
vv31:
vvch = *++VVCURSOR;
switch (vvch) {
case '=': goto vv104;
default: goto vv32;
}
vv32:
{
token->opcode = PHVOLT_T_DIV;
return 0;
}
vv33:
vvaccept = 2;
vvch = *(VVMARKER = ++VVCURSOR);
switch (vvch) {
case '.': goto vv106;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9': goto vv33;
default: goto vv35;
}
vv35:
{
token->opcode = PHVOLT_T_INTEGER;
token->value = estrndup(start, VVCURSOR - start);
token->len = VVCURSOR - start;
return 0;
}
vv36:
++VVCURSOR;
{
token->opcode = PHVOLT_T_COLON;
return 0;
}
vv38:
vvch = *++VVCURSOR;
switch (vvch) {
case '=': goto vv107;
case '>': goto vv109;
default: goto vv39;
}
vv39:
{
token->opcode = PHVOLT_T_LESS;
return 0;
}
vv40:
vvch = *++VVCURSOR;
switch (vvch) {
case '=': goto vv111;
default: goto vv41;
}
vv41:
{
token->opcode = PHVOLT_T_ASSIGN;
return 0;
}
vv42:
vvch = *++VVCURSOR;
switch (vvch) {
case '=': goto vv113;
default: goto vv43;
}
vv43:
{
token->opcode = PHVOLT_T_GREATER;
return 0;
}
vv44:
++VVCURSOR;
{
token->opcode = PHVOLT_T_QUESTION;
return 0;
}
vv46:
vvch = *++VVCURSOR;
switch (vvch) {
case 'N':
case 'n': goto vv115;
case 'U':
case 'u': goto vv116;
default: goto vv54;
}
vv47:
{
token->opcode = PHVOLT_T_IDENTIFIER;
token->value = estrndup(start, VVCURSOR - start);
token->len = VVCURSOR - start;
return 0;
}
vv48:
vvch = *++VVCURSOR;
switch (vvch) {
case 'L':
case 'l': goto vv117;
case 'R':
case 'r': goto vv118;
default: goto vv54;
}
vv49:
vvch = *++VVCURSOR;
switch (vvch) {
case 'A':
case 'a': goto vv119;
case 'O':
case 'o': goto vv120;
default: goto vv54;
}
vv50:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv121;
case 'O':
case 'o': goto vv122;
default: goto vv54;
}
vv51:
vvch = *++VVCURSOR;
switch (vvch) {
case 'L':
case 'l': goto vv124;
case 'M':
case 'm': goto vv125;
case 'N':
case 'n': goto vv126;
case 'V':
case 'v': goto vv127;
case 'X':
case 'x': goto vv128;
default: goto vv54;
}
vv52:
vvch = *++VVCURSOR;
switch (vvch) {
case 'A':
case 'a': goto vv129;
case 'O':
case 'o': goto vv130;
default: goto vv54;
}
vv53:
vvch = *++VVCURSOR;
vv54:
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv47;
}
vv55:
vvch = *++VVCURSOR;
switch (vvch) {
case 'F':
case 'f': goto vv131;
case 'N':
case 'n': goto vv133;
case 'S':
case 's': goto vv135;
case 'T':
case 't': goto vv137;
default: goto vv54;
}
vv56:
vvch = *++VVCURSOR;
switch (vvch) {
case 'A':
case 'a': goto vv138;
default: goto vv54;
}
vv57:
vvch = *++VVCURSOR;
switch (vvch) {
case 'O':
case 'o': goto vv139;
case 'U':
case 'u': goto vv140;
default: goto vv54;
}
vv58:
vvch = *++VVCURSOR;
switch (vvch) {
case 'D':
case 'd': goto vv141;
case 'R':
case 'r': goto vv142;
default: goto vv54;
}
vv59:
vvch = *++VVCURSOR;
switch (vvch) {
case 'A':
case 'a': goto vv144;
case 'E':
case 'e': goto vv145;
default: goto vv54;
}
vv60:
vvch = *++VVCURSOR;
switch (vvch) {
case 'C':
case 'c': goto vv146;
case 'E':
case 'e': goto vv147;
case 'W':
case 'w': goto vv148;
default: goto vv54;
}
vv61:
vvch = *++VVCURSOR;
switch (vvch) {
case 'R':
case 'r': goto vv149;
default: goto vv54;
}
vv62:
vvch = *++VVCURSOR;
switch (vvch) {
case 'I':
case 'i': goto vv150;
default: goto vv54;
}
vv63:
++VVCURSOR;
{
token->opcode = PHVOLT_T_SBRACKET_OPEN;
return 0;
}
vv65:
vvch = *++VVCURSOR;
switch (vvch) {
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv5;
}
vv66:
++VVCURSOR;
{
token->opcode = PHVOLT_T_SBRACKET_CLOSE;
return 0;
}
vv68:
vvch = *++VVCURSOR;
switch (vvch) {
case 'F':
case 'f': goto vv131;
case 'N':
case 'n': goto vv133;
case 'S': goto vv135;
case 'T':
case 't': goto vv137;
case 's': goto vv151;
default: goto vv54;
}
vv69:
vvch = *++VVCURSOR;
switch (vvch) {
case '%': goto vv152;
case '{': goto vv154;
default: goto vv70;
}
vv70:
{
token->opcode = PHVOLT_T_CBRACKET_OPEN;
return 0;
}
vv71:
++VVCURSOR;
{
token->opcode = PHVOLT_T_PIPE;
return 0;
}
vv73:
vvch = *++VVCURSOR;
switch (vvch) {
case '}': goto vv156;
default: goto vv74;
}
vv74:
{
token->opcode = PHVOLT_T_CBRACKET_CLOSE;
return 0;
}
vv75:
++VVCURSOR;
{
token->opcode = PHVOLT_T_CONCAT;
return 0;
}
vv77:
vvch = *++VVCURSOR;
switch (vvch) {
case '=': goto vv158;
default: goto vv78;
}
vv78:
{
token->opcode = PHVOLT_T_NOTEQUALS;
return 0;
}
vv79:
vvch = *++VVCURSOR;
vv80:
switch (vvch) {
case 0x00: goto vv81;
case '"': goto vv82;
case '\\': goto vv84;
default: goto vv79;
}
vv81:
VVCURSOR = VVMARKER;
switch (vvaccept) {
case 0: goto vv5;
case 1: goto vv28;
case 2: goto vv35;
default: goto vv136;
}
vv82:
++VVCURSOR;
{
start++;
token->opcode = PHVOLT_T_STRING;
token->value = estrndup(start, VVCURSOR - start - 1);
token->len = VVCURSOR - start - 1;
return 0;
}
vv84:
vvch = *++VVCURSOR;
switch (vvch) {
case '\n': goto vv81;
default: goto vv79;
}
vv85:
++VVCURSOR;
{
s->mode = PHVOLT_MODE_RAW;
token->opcode = PHVOLT_T_CLOSE_DELIMITER;
return 0;
}
vv87:
vvch = *++VVCURSOR;
vv88:
switch (vvch) {
case 0x00: goto vv81;
case '\'': goto vv82;
case '\\': goto vv89;
default: goto vv87;
}
vv89:
vvch = *++VVCURSOR;
switch (vvch) {
case '\n': goto vv81;
default: goto vv87;
}
vv90:
++VVCURSOR;
{
token->opcode = PHVOLT_T_MUL_ASSIGN;
return 0;
}
vv92:
++VVCURSOR;
{
token->opcode = PHVOLT_T_INCR;
return 0;
}
vv94:
++VVCURSOR;
{
token->opcode = PHVOLT_T_ADD_ASSIGN;
return 0;
}
vv96:
vvch = *++VVCURSOR;
switch (vvch) {
case '}': goto vv160;
default: goto vv81;
}
vv97:
++VVCURSOR;
{
token->opcode = PHVOLT_T_DECR;
return 0;
}
vv99:
++VVCURSOR;
{
token->opcode = PHVOLT_T_SUB_ASSIGN;
return 0;
}
vv101:
vvch = *++VVCURSOR;
switch (vvch) {
case '}': goto vv162;
default: goto vv81;
}
vv102:
++VVCURSOR;
{
token->opcode = PHVOLT_T_RANGE;
return 0;
}
vv104:
++VVCURSOR;
{
token->opcode = PHVOLT_T_DIV_ASSIGN;
return 0;
}
vv106:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9': goto vv164;
default: goto vv81;
}
vv107:
++VVCURSOR;
{
token->opcode = PHVOLT_T_LESSEQUAL;
return 0;
}
vv109:
++VVCURSOR;
{
token->opcode = PHVOLT_T_NOTEQUALS;
return 0;
}
vv111:
vvch = *++VVCURSOR;
switch (vvch) {
case '=': goto vv167;
default: goto vv112;
}
vv112:
{
token->opcode = PHVOLT_T_EQUALS;
return 0;
}
vv113:
++VVCURSOR;
{
token->opcode = PHVOLT_T_GREATEREQUAL;
return 0;
}
vv115:
vvch = *++VVCURSOR;
switch (vvch) {
case 'D':
case 'd': goto vv169;
default: goto vv54;
}
vv116:
vvch = *++VVCURSOR;
switch (vvch) {
case 'T':
case 't': goto vv171;
default: goto vv54;
}
vv117:
vvch = *++VVCURSOR;
switch (vvch) {
case 'O':
case 'o': goto vv172;
default: goto vv54;
}
vv118:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv173;
default: goto vv54;
}
vv119:
vvch = *++VVCURSOR;
switch (vvch) {
case 'C':
case 'c': goto vv174;
case 'L':
case 'l': goto vv175;
case 'S':
case 's': goto vv176;
default: goto vv54;
}
vv120:
vvch = *++VVCURSOR;
switch (vvch) {
case 'N':
case 'n': goto vv177;
default: goto vv54;
}
vv121:
vvch = *++VVCURSOR;
switch (vvch) {
case 'F':
case 'f': goto vv178;
default: goto vv54;
}
vv122:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv123;
}
vv123:
{
s->statement_position++;
token->opcode = PHVOLT_T_DO;
return 0;
}
vv124:
vvch = *++VVCURSOR;
switch (vvch) {
case 'S':
case 's': goto vv179;
default: goto vv54;
}
vv125:
vvch = *++VVCURSOR;
switch (vvch) {
case 'P':
case 'p': goto vv180;
default: goto vv54;
}
vv126:
vvch = *++VVCURSOR;
switch (vvch) {
case 'D':
case 'd': goto vv181;
default: goto vv54;
}
vv127:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv182;
default: goto vv54;
}
vv128:
vvch = *++VVCURSOR;
switch (vvch) {
case 'T':
case 't': goto vv183;
default: goto vv54;
}
vv129:
vvch = *++VVCURSOR;
switch (vvch) {
case 'L':
case 'l': goto vv184;
default: goto vv54;
}
vv130:
vvch = *++VVCURSOR;
switch (vvch) {
case 'R':
case 'r': goto vv185;
default: goto vv54;
}
vv131:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv132;
}
vv132:
{
s->statement_position++;
token->opcode = PHVOLT_T_IF;
return 0;
}
vv133:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
case 'C':
case 'c': goto vv187;
default: goto vv134;
}
vv134:
{
token->opcode = PHVOLT_T_IN;
return 0;
}
vv135:
vvaccept = 3;
vvch = *(VVMARKER = ++VVCURSOR);
switch (vvch) {
case ' ': goto vv188;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv136;
}
vv136:
{
if (s->active_token == PHVOLT_T_DOT) {
token->opcode = PHVOLT_T_IDENTIFIER;
token->value = estrndup(start, VVCURSOR - start);
token->len = VVCURSOR - start;
} else {
s->statement_position++;
token->opcode = PHVOLT_T_IS;
}
return 0;
}
vv137:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv189;
default: goto vv54;
}
vv138:
vvch = *++VVCURSOR;
switch (vvch) {
case 'C':
case 'c': goto vv190;
default: goto vv54;
}
vv139:
vvch = *++VVCURSOR;
switch (vvch) {
case 'T':
case 't': goto vv191;
default: goto vv54;
}
vv140:
vvch = *++VVCURSOR;
switch (vvch) {
case 'L':
case 'l': goto vv193;
case 'M':
case 'm': goto vv194;
default: goto vv54;
}
vv141:
vvch = *++VVCURSOR;
switch (vvch) {
case 'D':
case 'd': goto vv195;
default: goto vv54;
}
vv142:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv143;
}
vv143:
{
token->opcode = PHVOLT_T_OR;
return 0;
}
vv144:
vvch = *++VVCURSOR;
switch (vvch) {
case 'W':
case 'w': goto vv197;
default: goto vv54;
}
vv145:
vvch = *++VVCURSOR;
switch (vvch) {
case 'T':
case 't': goto vv199;
default: goto vv54;
}
vv146:
vvch = *++VVCURSOR;
switch (vvch) {
case 'A':
case 'a': goto vv200;
default: goto vv54;
}
vv147:
vvch = *++VVCURSOR;
switch (vvch) {
case 'T':
case 't': goto vv201;
default: goto vv54;
}
vv148:
vvch = *++VVCURSOR;
switch (vvch) {
case 'I':
case 'i': goto vv203;
default: goto vv54;
}
vv149:
vvch = *++VVCURSOR;
switch (vvch) {
case 'U':
case 'u': goto vv204;
default: goto vv54;
}
vv150:
vvch = *++VVCURSOR;
switch (vvch) {
case 'T':
case 't': goto vv205;
default: goto vv54;
}
vv151:
vvaccept = 3;
vvch = *(VVMARKER = ++VVCURSOR);
switch (vvch) {
case ' ': goto vv206;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv136;
}
vv152:
vvch = *++VVCURSOR;
switch (vvch) {
case '-': goto vv207;
default: goto vv153;
}
vv153:
{
s->whitespace_control = 0;
token->opcode = PHVOLT_T_OPEN_DELIMITER;
return 0;
}
vv154:
vvch = *++VVCURSOR;
switch (vvch) {
case '-': goto vv209;
default: goto vv155;
}
vv155:
{
s->whitespace_control = 0;
s->statement_position++;
token->opcode = PHVOLT_T_OPEN_EDELIMITER;
return 0;
}
vv156:
++VVCURSOR;
{
s->mode = PHVOLT_MODE_RAW;
token->opcode = PHVOLT_T_CLOSE_EDELIMITER;
return 0;
}
vv158:
++VVCURSOR;
{
token->opcode = PHVOLT_T_NOTIDENTICAL;
return 0;
}
vv160:
++VVCURSOR;
{
s->mode = PHVOLT_MODE_RAW;
s->whitespace_control = 1;
token->opcode = PHVOLT_T_CLOSE_DELIMITER;
return 0;
}
vv162:
++VVCURSOR;
{
s->mode = PHVOLT_MODE_RAW;
s->whitespace_control = 1;
token->opcode = PHVOLT_T_CLOSE_EDELIMITER;
return 0;
}
vv164:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9': goto vv164;
default: goto vv166;
}
vv166:
{
token->opcode = PHVOLT_T_DOUBLE;
token->value = estrndup(start, VVCURSOR - start);
token->len = VVCURSOR - start;
return 0;
}
vv167:
++VVCURSOR;
{
token->opcode = PHVOLT_T_IDENTICAL;
return 0;
}
vv169:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv170;
}
vv170:
{
token->opcode = PHVOLT_T_AND;
return 0;
}
vv171:
vvch = *++VVCURSOR;
switch (vvch) {
case 'O':
case 'o': goto vv211;
default: goto vv54;
}
vv172:
vvch = *++VVCURSOR;
switch (vvch) {
case 'C':
case 'c': goto vv212;
default: goto vv54;
}
vv173:
vvch = *++VVCURSOR;
switch (vvch) {
case 'A':
case 'a': goto vv213;
default: goto vv54;
}
vv174:
vvch = *++VVCURSOR;
switch (vvch) {
case 'H':
case 'h': goto vv214;
default: goto vv54;
}
vv175:
vvch = *++VVCURSOR;
switch (vvch) {
case 'L':
case 'l': goto vv215;
default: goto vv54;
}
vv176:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv217;
default: goto vv54;
}
vv177:
vvch = *++VVCURSOR;
switch (vvch) {
case 'T':
case 't': goto vv219;
default: goto vv54;
}
vv178:
vvch = *++VVCURSOR;
switch (vvch) {
case 'A':
case 'a': goto vv220;
case 'I':
case 'i': goto vv221;
default: goto vv54;
}
vv179:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv222;
default: goto vv54;
}
vv180:
vvch = *++VVCURSOR;
switch (vvch) {
case 'T':
case 't': goto vv224;
default: goto vv54;
}
vv181:
vvch = *++VVCURSOR;
switch (vvch) {
case 'A':
case 'a': goto vv225;
case 'B':
case 'b': goto vv226;
case 'C':
case 'c': goto vv227;
case 'F':
case 'f': goto vv228;
case 'I':
case 'i': goto vv229;
case 'M':
case 'm': goto vv230;
case 'R':
case 'r': goto vv231;
case 'S':
case 's': goto vv232;
default: goto vv54;
}
vv182:
vvch = *++VVCURSOR;
switch (vvch) {
case 'N':
case 'n': goto vv233;
default: goto vv54;
}
vv183:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv235;
default: goto vv54;
}
vv184:
vvch = *++VVCURSOR;
switch (vvch) {
case 'S':
case 's': goto vv236;
default: goto vv54;
}
vv185:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv186;
}
vv186:
{
s->statement_position++;
token->opcode = PHVOLT_T_FOR;
return 0;
}
vv187:
vvch = *++VVCURSOR;
switch (vvch) {
case 'L':
case 'l': goto vv237;
default: goto vv54;
}
vv188:
vvch = *++VVCURSOR;
switch (vvch) {
case 'N':
case 'n': goto vv238;
default: goto vv81;
}
vv189:
vvch = *++VVCURSOR;
switch (vvch) {
case 'R':
case 'r': goto vv239;
default: goto vv54;
}
vv190:
vvch = *++VVCURSOR;
switch (vvch) {
case 'R':
case 'r': goto vv240;
default: goto vv54;
}
vv191:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv192;
}
vv192:
{
s->statement_position++;
token->opcode = PHVOLT_T_NOT;
return 0;
}
vv193:
vvch = *++VVCURSOR;
switch (vvch) {
case 'L':
case 'l': goto vv241;
default: goto vv54;
}
vv194:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv243;
default: goto vv54;
}
vv195:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv196;
}
vv196:
{
s->statement_position++;
token->opcode = PHVOLT_T_ODD;
return 0;
}
vv197:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv198;
}
vv198:
{
s->statement_position++;
token->opcode = PHVOLT_T_RAW;
return 0;
}
vv199:
vvch = *++VVCURSOR;
switch (vvch) {
case 'U':
case 'u': goto vv244;
default: goto vv54;
}
vv200:
vvch = *++VVCURSOR;
switch (vvch) {
case 'L':
case 'l': goto vv245;
default: goto vv54;
}
vv201:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv202;
}
vv202:
{
if (s->active_token == PHVOLT_T_DOT) {
token->opcode = PHVOLT_T_IDENTIFIER;
token->value = estrndup(start, VVCURSOR - start);
token->len = VVCURSOR - start;
} else {
token->opcode = PHVOLT_T_SET;
}
return 0;
}
vv203:
vvch = *++VVCURSOR;
switch (vvch) {
case 'T':
case 't': goto vv246;
default: goto vv54;
}
vv204:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv247;
default: goto vv54;
}
vv205:
vvch = *++VVCURSOR;
switch (vvch) {
case 'H':
case 'h': goto vv249;
default: goto vv54;
}
vv206:
vvch = *++VVCURSOR;
switch (vvch) {
case 'N':
case 'n': goto vv238;
default: goto vv252;
}
vv207:
++VVCURSOR;
{
s->whitespace_control = 0;
token->opcode = PHVOLT_T_OPEN_DELIMITER;
return 0;
}
vv209:
++VVCURSOR;
{
s->whitespace_control = 0;
s->statement_position++;
token->opcode = PHVOLT_T_OPEN_EDELIMITER;
return 0;
}
vv211:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv253;
default: goto vv54;
}
vv212:
vvch = *++VVCURSOR;
switch (vvch) {
case 'K':
case 'k': goto vv254;
default: goto vv54;
}
vv213:
vvch = *++VVCURSOR;
switch (vvch) {
case 'K':
case 'k': goto vv256;
default: goto vv54;
}
vv214:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv258;
default: goto vv54;
}
vv215:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv216;
}
vv216:
{
s->statement_position++;
token->opcode = PHVOLT_T_CALL;
return 0;
}
vv217:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv218;
}
vv218:
{
token->opcode = PHVOLT_T_CASE;
return 0;
}
vv219:
vvch = *++VVCURSOR;
switch (vvch) {
case 'I':
case 'i': goto vv260;
default: goto vv54;
}
vv220:
vvch = *++VVCURSOR;
switch (vvch) {
case 'U':
case 'u': goto vv261;
default: goto vv54;
}
vv221:
vvch = *++VVCURSOR;
switch (vvch) {
case 'N':
case 'n': goto vv262;
default: goto vv54;
}
vv222:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'G':
case 'H':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'g':
case 'h':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
case 'F':
case 'f': goto vv263;
case 'I':
case 'i': goto vv264;
default: goto vv223;
}
vv223:
{
token->opcode = PHVOLT_T_ELSE;
return 0;
}
vv224:
vvch = *++VVCURSOR;
switch (vvch) {
case 'Y':
case 'y': goto vv265;
default: goto vv54;
}
vv225:
vvch = *++VVCURSOR;
switch (vvch) {
case 'U':
case 'u': goto vv267;
default: goto vv54;
}
vv226:
vvch = *++VVCURSOR;
switch (vvch) {
case 'L':
case 'l': goto vv268;
default: goto vv54;
}
vv227:
vvch = *++VVCURSOR;
switch (vvch) {
case 'A':
case 'a': goto vv269;
default: goto vv54;
}
vv228:
vvch = *++VVCURSOR;
switch (vvch) {
case 'O':
case 'o': goto vv270;
default: goto vv54;
}
vv229:
vvch = *++VVCURSOR;
switch (vvch) {
case 'F':
case 'f': goto vv271;
default: goto vv54;
}
vv230:
vvch = *++VVCURSOR;
switch (vvch) {
case 'A':
case 'a': goto vv273;
default: goto vv54;
}
vv231:
vvch = *++VVCURSOR;
switch (vvch) {
case 'A':
case 'a': goto vv274;
default: goto vv54;
}
vv232:
vvch = *++VVCURSOR;
switch (vvch) {
case 'W':
case 'w': goto vv275;
default: goto vv54;
}
vv233:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv234;
}
vv234:
{
s->statement_position++;
token->opcode = PHVOLT_T_EVEN;
return 0;
}
vv235:
vvch = *++VVCURSOR;
switch (vvch) {
case 'N':
case 'n': goto vv276;
default: goto vv54;
}
vv236:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv277;
default: goto vv54;
}
vv237:
vvch = *++VVCURSOR;
switch (vvch) {
case 'U':
case 'u': goto vv279;
default: goto vv54;
}
vv238:
vvch = *++VVCURSOR;
switch (vvch) {
case 'O':
case 'o': goto vv280;
default: goto vv81;
}
vv239:
vvch = *++VVCURSOR;
switch (vvch) {
case 'A':
case 'a': goto vv281;
default: goto vv54;
}
vv240:
vvch = *++VVCURSOR;
switch (vvch) {
case 'O':
case 'o': goto vv282;
default: goto vv54;
}
vv241:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv242;
}
vv242:
{
token->opcode = PHVOLT_T_NULL;
return 0;
}
vv243:
vvch = *++VVCURSOR;
switch (vvch) {
case 'R':
case 'r': goto vv284;
default: goto vv54;
}
vv244:
vvch = *++VVCURSOR;
switch (vvch) {
case 'R':
case 'r': goto vv285;
default: goto vv54;
}
vv245:
vvch = *++VVCURSOR;
switch (vvch) {
case 'A':
case 'a': goto vv286;
default: goto vv54;
}
vv246:
vvch = *++VVCURSOR;
switch (vvch) {
case 'C':
case 'c': goto vv287;
default: goto vv54;
}
vv247:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv248;
}
vv248:
{
token->opcode = PHVOLT_T_TRUE;
return 0;
}
vv249:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv250;
}
vv250:
{
token->opcode = PHVOLT_T_WITH;
return 0;
}
vv251:
vvch = *++VVCURSOR;
vv252:
switch (vvch) {
case ' ': goto vv251;
case 'n': goto vv288;
default: goto vv81;
}
vv253:
vvch = *++VVCURSOR;
switch (vvch) {
case 'S':
case 's': goto vv289;
default: goto vv54;
}
vv254:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv255;
}
vv255:
{
s->statement_position++;
token->opcode = PHVOLT_T_BLOCK;
return 0;
}
vv256:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv257;
}
vv257:
{
s->statement_position++;
token->opcode = PHVOLT_T_BREAK;
return 0;
}
vv258:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv259;
}
vv259:
{
s->statement_position++;
token->opcode = PHVOLT_T_CACHE;
return 0;
}
vv260:
vvch = *++VVCURSOR;
switch (vvch) {
case 'N':
case 'n': goto vv290;
default: goto vv54;
}
vv261:
vvch = *++VVCURSOR;
switch (vvch) {
case 'L':
case 'l': goto vv291;
default: goto vv54;
}
vv262:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv292;
default: goto vv54;
}
vv263:
vvch = *++VVCURSOR;
switch (vvch) {
case 'O':
case 'o': goto vv293;
default: goto vv54;
}
vv264:
vvch = *++VVCURSOR;
switch (vvch) {
case 'F':
case 'f': goto vv294;
default: goto vv54;
}
vv265:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv266;
}
vv266:
{
s->statement_position++;
token->opcode = PHVOLT_T_EMPTY;
return 0;
}
vv267:
vvch = *++VVCURSOR;
switch (vvch) {
case 'T':
case 't': goto vv296;
default: goto vv54;
}
vv268:
vvch = *++VVCURSOR;
switch (vvch) {
case 'O':
case 'o': goto vv297;
default: goto vv54;
}
vv269:
vvch = *++VVCURSOR;
switch (vvch) {
case 'C':
case 'c': goto vv298;
case 'L':
case 'l': goto vv299;
default: goto vv54;
}
vv270:
vvch = *++VVCURSOR;
switch (vvch) {
case 'R':
case 'r': goto vv300;
default: goto vv54;
}
vv271:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv272;
}
vv272:
{
token->opcode = PHVOLT_T_ENDIF;
return 0;
}
vv273:
vvch = *++VVCURSOR;
switch (vvch) {
case 'C':
case 'c': goto vv302;
default: goto vv54;
}
vv274:
vvch = *++VVCURSOR;
switch (vvch) {
case 'W':
case 'w': goto vv303;
default: goto vv54;
}
vv275:
vvch = *++VVCURSOR;
switch (vvch) {
case 'I':
case 'i': goto vv305;
default: goto vv54;
}
vv276:
vvch = *++VVCURSOR;
switch (vvch) {
case 'D':
case 'd': goto vv306;
default: goto vv54;
}
vv277:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv278;
}
vv278:
{
token->opcode = PHVOLT_T_FALSE;
return 0;
}
vv279:
vvch = *++VVCURSOR;
switch (vvch) {
case 'D':
case 'd': goto vv307;
default: goto vv54;
}
vv280:
vvch = *++VVCURSOR;
switch (vvch) {
case 'T':
case 't': goto vv308;
default: goto vv81;
}
vv281:
vvch = *++VVCURSOR;
switch (vvch) {
case 'B':
case 'b': goto vv310;
default: goto vv54;
}
vv282:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv283;
}
vv283:
{
s->statement_position++;
token->opcode = PHVOLT_T_MACRO;
return 0;
}
vv284:
vvch = *++VVCURSOR;
switch (vvch) {
case 'I':
case 'i': goto vv311;
default: goto vv54;
}
vv285:
vvch = *++VVCURSOR;
switch (vvch) {
case 'N':
case 'n': goto vv312;
default: goto vv54;
}
vv286:
vvch = *++VVCURSOR;
switch (vvch) {
case 'R':
case 'r': goto vv314;
default: goto vv54;
}
vv287:
vvch = *++VVCURSOR;
switch (vvch) {
case 'H':
case 'h': goto vv316;
default: goto vv54;
}
vv288:
vvch = *++VVCURSOR;
switch (vvch) {
case 'o': goto vv318;
default: goto vv81;
}
vv289:
vvch = *++VVCURSOR;
switch (vvch) {
case 'C':
case 'c': goto vv319;
default: goto vv54;
}
vv290:
vvch = *++VVCURSOR;
switch (vvch) {
case 'U':
case 'u': goto vv320;
default: goto vv54;
}
vv291:
vvch = *++VVCURSOR;
switch (vvch) {
case 'T':
case 't': goto vv321;
default: goto vv54;
}
vv292:
vvch = *++VVCURSOR;
switch (vvch) {
case 'D':
case 'd': goto vv323;
default: goto vv54;
}
vv293:
vvch = *++VVCURSOR;
switch (vvch) {
case 'R':
case 'r': goto vv325;
default: goto vv54;
}
vv294:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv295;
}
vv295:
{
token->opcode = PHVOLT_T_ELSEIF;
return 0;
}
vv296:
vvch = *++VVCURSOR;
switch (vvch) {
case 'O':
case 'o': goto vv327;
default: goto vv54;
}
vv297:
vvch = *++VVCURSOR;
switch (vvch) {
case 'C':
case 'c': goto vv328;
default: goto vv54;
}
vv298:
vvch = *++VVCURSOR;
switch (vvch) {
case 'H':
case 'h': goto vv329;
default: goto vv54;
}
vv299:
vvch = *++VVCURSOR;
switch (vvch) {
case 'L':
case 'l': goto vv330;
default: goto vv54;
}
vv300:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv301;
}
vv301:
{
token->opcode = PHVOLT_T_ENDFOR;
return 0;
}
vv302:
vvch = *++VVCURSOR;
switch (vvch) {
case 'R':
case 'r': goto vv332;
default: goto vv54;
}
vv303:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv304;
}
vv304:
{
s->statement_position++;
token->opcode = PHVOLT_T_ENDRAW;
return 0;
}
vv305:
vvch = *++VVCURSOR;
switch (vvch) {
case 'T':
case 't': goto vv333;
default: goto vv54;
}
vv306:
vvch = *++VVCURSOR;
switch (vvch) {
case 'S':
case 's': goto vv334;
default: goto vv54;
}
vv307:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv336;
default: goto vv54;
}
vv308:
++VVCURSOR;
{
s->statement_position++;
token->opcode = PHVOLT_T_NOTEQUALS;
return 0;
}
vv310:
vvch = *++VVCURSOR;
switch (vvch) {
case 'L':
case 'l': goto vv338;
default: goto vv54;
}
vv311:
vvch = *++VVCURSOR;
switch (vvch) {
case 'C':
case 'c': goto vv339;
default: goto vv54;
}
vv312:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv313;
}
vv313:
{
token->opcode = PHVOLT_T_RETURN;
return 0;
}
vv314:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv315;
}
vv315:
{
s->statement_position++;
token->opcode = PHVOLT_T_SCALAR;
return 0;
}
vv316:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv317;
}
vv317:
{
s->statement_position++;
token->opcode = PHVOLT_T_SWITCH;
return 0;
}
vv318:
vvch = *++VVCURSOR;
switch (vvch) {
case 't': goto vv341;
default: goto vv81;
}
vv319:
vvch = *++VVCURSOR;
switch (vvch) {
case 'A':
case 'a': goto vv343;
default: goto vv54;
}
vv320:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv344;
default: goto vv54;
}
vv321:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv322;
}
vv322:
{
token->opcode = PHVOLT_T_DEFAULT;
token->value = estrndup(start, VVCURSOR - start);
token->len = VVCURSOR - start;
return 0;
}
vv323:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv324;
}
vv324:
{
s->statement_position++;
token->opcode = PHVOLT_T_DEFINED;
return 0;
}
vv325:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv326;
}
vv326:
{
token->opcode = PHVOLT_T_ELSEFOR;
return 0;
}
vv327:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv346;
default: goto vv54;
}
vv328:
vvch = *++VVCURSOR;
switch (vvch) {
case 'K':
case 'k': goto vv347;
default: goto vv54;
}
vv329:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv349;
default: goto vv54;
}
vv330:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv331;
}
vv331:
{
token->opcode = PHVOLT_T_ENDCALL;
return 0;
}
vv332:
vvch = *++VVCURSOR;
switch (vvch) {
case 'O':
case 'o': goto vv351;
default: goto vv54;
}
vv333:
vvch = *++VVCURSOR;
switch (vvch) {
case 'C':
case 'c': goto vv353;
default: goto vv54;
}
vv334:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv335;
}
vv335:
{
s->statement_position++;
token->opcode = PHVOLT_T_EXTENDS;
return 0;
}
vv336:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv337;
}
vv337:
{
s->statement_position++;
token->opcode = PHVOLT_T_INCLUDE;
return 0;
}
vv338:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv354;
default: goto vv54;
}
vv339:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv340;
}
vv340:
{
s->statement_position++;
token->opcode = PHVOLT_T_NUMERIC;
return 0;
}
vv341:
++VVCURSOR;
{
s->statement_position++;
token->opcode = PHVOLT_T_NOTEQUALS;
return 0;
}
vv343:
vvch = *++VVCURSOR;
switch (vvch) {
case 'P':
case 'p': goto vv356;
default: goto vv54;
}
vv344:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv345;
}
vv345:
{
s->statement_position++;
token->opcode = PHVOLT_T_CONTINUE;
return 0;
}
vv346:
vvch = *++VVCURSOR;
switch (vvch) {
case 'S':
case 's': goto vv357;
default: goto vv54;
}
vv347:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv348;
}
vv348:
{
token->opcode = PHVOLT_T_ENDBLOCK;
return 0;
}
vv349:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv350;
}
vv350:
{
token->opcode = PHVOLT_T_ENDCACHE;
return 0;
}
vv351:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv352;
}
vv352:
{
token->opcode = PHVOLT_T_ENDMACRO;
return 0;
}
vv353:
vvch = *++VVCURSOR;
switch (vvch) {
case 'H':
case 'h': goto vv358;
default: goto vv54;
}
vv354:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv355;
}
vv355:
{
s->statement_position++;
token->opcode = PHVOLT_T_ITERABLE;
return 0;
}
vv356:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv360;
default: goto vv54;
}
vv357:
vvch = *++VVCURSOR;
switch (vvch) {
case 'C':
case 'c': goto vv362;
default: goto vv54;
}
vv358:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv359;
}
vv359:
{
token->opcode = PHVOLT_T_ENDSWITCH;
return 0;
}
vv360:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv361;
}
vv361:
{
s->statement_position++;
token->opcode = PHVOLT_T_AUTOESCAPE;
return 0;
}
vv362:
vvch = *++VVCURSOR;
switch (vvch) {
case 'A':
case 'a': goto vv363;
default: goto vv54;
}
vv363:
vvch = *++VVCURSOR;
switch (vvch) {
case 'P':
case 'p': goto vv364;
default: goto vv54;
}
vv364:
vvch = *++VVCURSOR;
switch (vvch) {
case 'E':
case 'e': goto vv365;
default: goto vv54;
}
vv365:
vvch = *++VVCURSOR;
switch (vvch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
case '\\':
case '_':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z': goto vv53;
default: goto vv366;
}
vv366:
{
s->statement_position++;
token->opcode = PHVOLT_T_ENDAUTOESCAPE;
return 0;
}
}
}
}
return status;
}
|
/*
* helper.h
*
* Created on: Dec 31, 2018
* Author: jan
*
* helper.h consists of helper functions for Internet applications
*/
#ifndef SRC_HELPER_H_
#define SRC_HELPER_H_
// includes
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netdb.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
/*
* error prints an error message to the stderr
*/
void error(char* message);
/*
* open_listener creates a socket
*/
int open_listener_socket();
/*
* open_socket opens a socket based on a host url
*/
int open_socket(char *host, char *port);
/*
* bind_to_port binds to port 30000
*/
void bind_to_port(int socket, int port);
/*
* say sends a string to socket
*/
int say(int socket, char *s);
/*
* read_in reads characters from the socket until we encounter /n
*/
int read_in(int socket, char *buf, int len);
#endif /* SRC_HELPER_H_ */
|
/* SPDX-License-Identifier: BSD-2-Clause */
/***********************************************************************;
* Copyright (c) 2015 - 2017, Intel Corporation
* All rights reserved.
***********************************************************************/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "tss2_tpm2_types.h"
#include "tss2_mu.h"
#include "sysapi_util.h"
TSS2_RC Tss2_Sys_Hash_Prepare(
TSS2_SYS_CONTEXT *sysContext,
const TPM2B_MAX_BUFFER *data,
TPMI_ALG_HASH hashAlg,
TPMI_RH_HIERARCHY hierarchy)
{
_TSS2_SYS_CONTEXT_BLOB *ctx = syscontext_cast(sysContext);
TSS2_RC rval;
if (!ctx)
return TSS2_SYS_RC_BAD_REFERENCE;
if (IsAlgorithmWeak(hashAlg, 0))
return TSS2_SYS_RC_BAD_VALUE;
rval = CommonPreparePrologue(ctx, TPM2_CC_Hash);
if (rval)
return rval;
if (!data) {
ctx->decryptNull = 1;
rval = Tss2_MU_UINT16_Marshal(0, ctx->cmdBuffer,
ctx->maxCmdSize,
&ctx->nextData);
} else {
rval = Tss2_MU_TPM2B_MAX_BUFFER_Marshal(data, ctx->cmdBuffer,
ctx->maxCmdSize,
&ctx->nextData);
}
if (rval)
return rval;
rval = Tss2_MU_UINT16_Marshal(hashAlg, ctx->cmdBuffer,
ctx->maxCmdSize,
&ctx->nextData);
if (rval)
return rval;
rval = Tss2_MU_UINT32_Marshal(hierarchy, ctx->cmdBuffer,
ctx->maxCmdSize,
&ctx->nextData);
if (rval)
return rval;
ctx->decryptAllowed = 1;
ctx->encryptAllowed = 1;
ctx->authAllowed = 1;
return CommonPrepareEpilogue(ctx);
}
TSS2_RC Tss2_Sys_Hash_Complete(
TSS2_SYS_CONTEXT *sysContext,
TPM2B_DIGEST *outHash,
TPMT_TK_HASHCHECK *validation)
{
_TSS2_SYS_CONTEXT_BLOB *ctx = syscontext_cast(sysContext);
TSS2_RC rval;
if (!ctx)
return TSS2_SYS_RC_BAD_REFERENCE;
rval = CommonComplete(ctx);
if (rval)
return rval;
rval = Tss2_MU_TPM2B_DIGEST_Unmarshal(ctx->cmdBuffer,
ctx->maxCmdSize,
&ctx->nextData,
outHash);
if (rval)
return rval;
return Tss2_MU_TPMT_TK_HASHCHECK_Unmarshal(ctx->cmdBuffer,
ctx->maxCmdSize,
&ctx->nextData,
validation);
}
TSS2_RC Tss2_Sys_Hash(
TSS2_SYS_CONTEXT *sysContext,
TSS2L_SYS_AUTH_COMMAND const *cmdAuthsArray,
const TPM2B_MAX_BUFFER *data,
TPMI_ALG_HASH hashAlg,
TPMI_RH_HIERARCHY hierarchy,
TPM2B_DIGEST *outHash,
TPMT_TK_HASHCHECK *validation,
TSS2L_SYS_AUTH_RESPONSE *rspAuthsArray)
{
_TSS2_SYS_CONTEXT_BLOB *ctx = syscontext_cast(sysContext);
TSS2_RC rval;
rval = Tss2_Sys_Hash_Prepare(sysContext, data, hashAlg, hierarchy);
if (rval)
return rval;
rval = CommonOneCall(ctx, cmdAuthsArray, rspAuthsArray);
if (rval)
return rval;
return Tss2_Sys_Hash_Complete(sysContext, outHash, validation);
}
|
/***********************************************************************
* COSC1076 - Advanced Programming Techniques
* Summer 2015 Assignment #2
* Full Name : Joshua Richards
* Student Number : s3490925
* Course Code : COSC 1076
* Program Code : BP 162
* Start up code provided by David Shaw
* Based on 2014 code by Paul Miller and Virginia King
**********************************************************************/
/***********************************************************************
* This module handles the interface between the data files and the
* lists in memory. Most of these functions should only be run
* on program start with the exception of save_data which saves the
* data in the lists to the files.
**********************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "ets_type.h"
#include "ets_utility.h"
#include "loader.h"
#include "ets_manage.h"
/* loads data from the .dat files into memory. */
BOOLEAN load_data(struct ets * ets,
const char * equip_fname,
const char * member_fname,
const char * loan_fname)
{
FILE *equip_file = NULL;
FILE *member_file = NULL;
FILE *loan_file = NULL;
ets->equip_fname = equip_fname;
ets->member_fname = member_fname;
ets->loan_fname = loan_fname;
equip_file = fopen(equip_fname, "r");
if (equip_file == NULL)
{
fprintf(stderr, "Failed to open equip file\n");
return FALSE;
}
if (!read_file(ets->equip_list, equip_file, &new_equip, &comp_equip))
{
fprintf(stderr, "Problem reading equip file.\n");
safe_close_file(equip_file);
return FALSE;
}
safe_close_file(equip_file);
member_file = fopen(member_fname, "r");
if (member_file == NULL)
{
fprintf(stderr, "Failed to open equip file\n");
return FALSE;
}
if (!read_file(ets->member_list, member_file, &new_member, &comp_member))
{
fprintf(stderr, "Problem reading member file.\n");
safe_close_file(member_file);
return FALSE;
}
safe_close_file(member_file);
loan_file = fopen(loan_fname, "r");
if (loan_file == NULL)
{
fprintf(stderr, "Failed to open loan file\n");
return FALSE;
}
if (!read_file(ets->loan_list, loan_file, &new_loan, &comp_fake))
{
fprintf(stderr, "Problem reading member file.\n");
safe_close_file(loan_file);
return FALSE;
}
safe_close_file(loan_file);
set_longest_name(ets);
set_num_lent(ets);
adjust_available(ets);
return TRUE;
}
BOOLEAN read_file(struct list *list, FILE *file,
void * (*constructor)(char *, char *, char *),
int (*comp)(void *, void *))
{
void *data = NULL;
void *last_data = NULL;
char line[MAX_LINE_LENGTH];
char *str1 = NULL;
char *str2 = NULL;
char *str3 = NULL;
while (fgets(line, MAX_LINE_LENGTH, file) != NULL)
{
if (line[strlen(line) - 1] != '\n')
{
if (!feof(file))
{
fprintf(stderr, "Invalid file. ");
fprintf(stderr, "lines must be shorter than %d characters.\n",
MAX_LINE_LENGTH - 2);
return FALSE;
}
}
else
{
line[strlen(line) - 1] = '\0';
}
str1 = strtok(line, DELIM);
str2 = strtok(NULL, DELIM);
str3 = strtok(NULL, DELIM);
if (str1 == NULL || str2 == NULL || str3 == NULL)
{
fprintf(stderr, "Invalid file\n");
return FALSE;
}
data = constructor(str1, str2, str3);
if (data == NULL)
{
fprintf(stderr, "Failed to create item\n");
free(data);
return FALSE;
}
if (comp(last_data, data) > 0)
{
printf("Warning: file is not sorted.\n");
printf("Saved data will be sorted.");
printf(" Select 'Abort' from menu to override\n");
}
if (!insert(list, data, comp))
{
fprintf(stderr, "Failed to insert item\n");
free(data);
return FALSE;
}
str1 = str2 = str3 = NULL;
last_data = data;
}
return TRUE;
}
/* loops through loan list and alters available
* values on corresponding equip to reflect each loan
* this is only intended to be run immmediately
* after loading data from files
* This operation must be performed manually
* if a new loan is made while during the session
*/
BOOLEAN adjust_available(struct ets *ets)
{
struct list_node *node = ets->loan_list->head;
struct equip *equip = NULL;
struct loan *loan = NULL;
while (node != NULL)
{
loan = node->data;
equip = find_equip(ets, loan->equip_id);
if (equip == NULL)
{
return FALSE;
}
equip->available -= loan->qty;
if (equip->available < 0)
{
return FALSE;
}
node = node->next;
equip = NULL;
}
return TRUE;
}
/* loops thorugh the loan list and increments
* each member's num_lent value to reflect thier loans */
BOOLEAN set_num_lent(struct ets *ets)
{
struct list_node *node = NULL;
struct member *member = NULL;
struct loan *loan = NULL;
node = ets->loan_list->head;
while (node != NULL)
{
loan = node->data;
member = find_member(ets, loan->member_id);
if (member == NULL)
{
return FALSE;
}
member->num_lent += loan->qty;
node = node->next;
member = NULL;
}
return TRUE;
}
/* sets the longest name property on the equip
* and member list.
* can be called at any time but must be called
* immediately after loading data from files */
BOOLEAN set_longest_name(struct ets *ets)
{
struct list_node *node = ets->equip_list->head;
struct equip *equip = NULL;
struct member *member = NULL;
int longest = ets->equip_list->longest_name;
int curr_length;
if (node == NULL)
{
return FALSE;
}
while (node != NULL)
{
equip = node->data;
longest = max(strlen(equip->name), longest);
node = node->next;
}
ets->equip_list->longest_name = longest;
node = ets->member_list->head;
longest = ets->member_list->longest_name;
if (node == NULL)
{
return FALSE;
}
while (node != NULL)
{
member = node->data;
curr_length = strlen(member->first_name) + strlen(member->last_name) + 1;
longest = max(curr_length, longest);
node = node->next;
}
ets->member_list->longest_name = longest;
return TRUE;
}
BOOLEAN save_data(struct ets *ets)
{
FILE *equip_file = NULL;
FILE *member_file = NULL;
FILE *loan_file = NULL;
struct list_node *node = NULL;
struct equip *equip = NULL;
struct member *member = NULL;
struct loan *loan = NULL;
equip_file = fopen(ets->equip_fname, "w");
if (equip_file == NULL)
{
fprintf(stderr, "Error. Couldn't open equip file.\n");
return FALSE;
}
node = ets->equip_list->head;
while (node != NULL)
{
equip = node->data;
fprintf(equip_file, "%s|%s|%d\n", equip->id, equip->name, equip->total);
node = node->next;
}
safe_close_file(equip_file);
member_file = fopen(ets->member_fname, "w");
if (member_file == NULL)
{
fprintf(stderr, "Error. Couldn't open member file.\n");
return FALSE;
}
node = ets->member_list->head;
while (node != NULL)
{
member = node->data;
fprintf(member_file, "%s|%s|%s\n", member->id, member->last_name,
member->first_name);
node = node->next;
}
safe_close_file(member_file);
loan_file = fopen(ets->loan_fname, "w");
if (loan_file == NULL)
{
fprintf(stderr, "Error. Couldn't open loan file.\n");
return FALSE;
}
node = ets->loan_list->head;
while (node != NULL)
{
loan = node->data;
fprintf(loan_file, "%s|%s|%d\n", loan->member_id, loan->equip_id,
loan->qty);
node = node->next;
}
safe_close_file(loan_file);
return TRUE;
}
/* fake comparison function so that it appears
* to read_file that loans are sorted. comp_loan
* is designed to force a tail insertion, preserving
* the original order of the file */
int comp_fake(void *d1, void *d2)
{
return -1;
}
|
#include <stdio.h>
#include <sys/mman.h>
#include <stdlib.h>
#include <termios.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <linux/fb.h>
#include <string.h>
#define BLUETOOTH_DEV "/dev/ttyUSB0"
#define BAUDRATE 9600
int main(void)
{
int fd;
char w1;
char r1;
char buf[255];
int i=0;
int check_read = 0;
int check_write;
char c1[2];
char ch;
int cnt = 0;
char gar;
char data[10] = {'a', 'b', 'c','d','e','f','g','h', 'i','j'};
fflush(stdin);
struct termios oldtio,newtio, options;
if((fd = open(BLUETOOTH_DEV, O_RDWR | O_NOCTTY ))< 0)
{
perror("open error");
exit(-1);
}
fcntl(fd, F_SETFL); // Configure port reading
tcgetattr(fd, &options); // Get the current options for the port
cfsetispeed(&options, B9600); // Set the baud rates to 230400
cfsetospeed(&options, B9600);
options.c_cflag |= (CLOCAL | CREAD); // Enable the receiver and set local mode
options.c_cflag &= ~PARENB; // No parity bit
options.c_cflag &= ~CSTOPB; // 1 stop bit
options.c_cflag &= ~CSIZE; // Mask data size
options.c_cflag |= CS8; // Select 8 data bits
options.c_cflag &= ~CRTSCTS; // Disable hardware flow control
// Enable data to be processed as raw input
options.c_lflag &= ~(ICANON | ECHO | ISIG);
// Set the new attributes
tcsetattr(fd, TCSANOW, &options);
printf("ready\n");
while(1) {
(void)read(fd, &ch,1);
c1[0] = c1[1];
c1[1] = ch;
printf("recv[%d] : %s\n", cnt++, c1);
if(c1[0] == 'G' && c1[1] == 'O') {
(void)read(fd, &ch,1);
break;
}
}
fflush(stdin);
fflush(stdout);
while(1) {
for (i =0 ; i < 10;i++){
(void)write(fd, &data[i%10], 1);
r1 = 0x0;
while( r1 != 0xa ) {
check_read += read(fd, &r1,1);
printf("check_Read : (%d), r1 : (%c)(%X) ", check_read, r1, r1);
}
}
fflush(stdin);
while( r1 != 0xa ) {
check_read += read(fd, &r1,1);
printf("check_Read : (%d), r1 : (%c)(%X) ", check_read, r1, r1);
}
r1 = 0x0;
}
return 0;
}
|
#ifndef _BLUTOOTH_H
#define _BLUTOOTH_H
#include "main.h"
#define BLUTOOTH_USART UART4
#define BLUTOOTH_USART_CLK RCC_APB1Periph_UART4
#define BLUTOOTH_USART_IRQ UART4_IRQn
#define BLUTOOTH_PORT_CLK RCC_AHB1Periph_GPIOC
#define BLUTOOTH_TX_PORT GPIOC
#define BLUTOOTH_TX_PIN GPIO_Pin_10
#define BLUTOOTH_TX_PORT_CLK RCC_AHB1Periph_GPIOC
#define BLUTOOTH_RX_PORT GPIOC
#define BLUTOOTH_RX_PIN GPIO_Pin_11
#define BLUTOOTH_RX_PORT_CLK RCC_AHB1Periph_GPIOC
void BLUTOOTH_Configuration(void);
void BLUTOOTH_Run(void);
void Usart4_Init(u32 bound, u16 wordLength, u16 stopBit, u16 parity);
void Usart4_Send_Data(char *buf,u16 len);
#endif
|
// /adm/simul_efun/effective_light.
// from the Nightmare mudlib
// returns the total effective light available to a player
// taking into effect her sight_bonus and any personal
// object she may be carrying that modify her own personal light
// Idea by Descartes, coded by Valodin 1-19-93
// recoded by Nulvect 2012-Feb-11
int effective_light(object who) {
int light;
int sight;
if (!who) return 0;
// make sure newbies can see
if (userp(who) && who->query_level() <= 5) return 1;
// start with ambient light
light = total_light(who);
// add light from objects we're carrying, like torches
foreach (object ob in all_inventory(who))
light += ob->query_property("light");
sight = who->query_sight_bonus();
// for + sight bonus, make it effectively lighter if it's dark
while (light < 0 && sight > 0) {
light++; sight--;
}
// for - sight bonus, make it effectively darker unless it's fairly light already
while (light < 1 && sight < 0) {
light--; sight++;
}
return light;
}
|
#include <stdio.h>
unsigned int le_to_be(unsigned int value);
int main(int argc, char **argv) {
unsigned int data = 0xAABBCCDD;
printf("the value is %X \n", data);
le_to_be(data);
return 0;
}
unsigned int le_to_be(unsigned int value) {
unsigned int be = 0x00;
unsigned char *tmp;
tmp = &value;
unsigned char i = 4;
unsigned char j = 0;
//be = be | *(tmp) << 24;
//be = be | *(tmp+1) << 16;
//be = be | *(tmp+2) << 8;
//be = be | *(tmp+3) ;
while(--i){
be = be | *(tmp + j++) << i * 8;
}
printf("the value is %X \n", be);
return be;
}
|
int scan_int(){
int number;
number = 0;
scanf("%d",&number);
return number;
}
double scan_double(){
double number;
number = 0.0f;
scanf("%lf",&number);
return number;
}
float scan_float(){
float number;
number = 0.0f;
scanf("%f",&number);
return number;
}
char scan_char(){
char ch;
ch = '\0';
scanf("%c",&ch);
return ch;
}
char* scan_string(int size){
char *str;
str = (char *)malloc(size * sizeof(char));
scanf("%s",str);
return str;
}
|
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <netdb.h>
#include <unistd.h>
#include <stdbool.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <stdint.h>
#include <pthread.h>
int socket_recv(int clientSocket, void** buffer, int reserveSpace){
char* sizeStr = malloc(sizeof(char)*11);
if (recv(clientSocket, sizeStr, 11, MSG_WAITALL) == 11){
int size = atoi(sizeStr);
free(sizeStr);
if(reserveSpace){
*buffer = malloc(size);
}
int magicSocketNumber = 32768;
char* bufAuxiliar = malloc(size);
if(size <= magicSocketNumber){
if(recv(clientSocket, bufAuxiliar, size, MSG_WAITALL)==size){
memcpy(*buffer, bufAuxiliar, size);
free(bufAuxiliar);
return size;
}
free(bufAuxiliar);
return -1;
}else{
int desplazamientoBuffer = 0;
div_t divisionEnPartes = div(size, magicSocketNumber);
int nPartes = divisionEnPartes.quot;
int resto = divisionEnPartes.rem;
int i;
for(i=0 ; i<nPartes; i++){
char* bufferMagicNumber = malloc(magicSocketNumber*sizeof(char));
if(recv(clientSocket, bufferMagicNumber, magicSocketNumber, MSG_WAITALL) == magicSocketNumber){
memcpy(bufAuxiliar+desplazamientoBuffer, bufferMagicNumber, magicSocketNumber);
desplazamientoBuffer += magicSocketNumber;
free(bufferMagicNumber);
}else{
free(bufferMagicNumber);
return -1;
}
}
if(resto > 0){
char* bufferResto = malloc(resto*sizeof(char));
if(recv(clientSocket, bufferResto, resto, MSG_WAITALL) == resto){
memcpy(bufAuxiliar+desplazamientoBuffer, bufferResto, resto);
free(bufferResto);
}else{
free(bufferResto);
return -1;
}
}
memcpy(*buffer, bufAuxiliar, size);
free(bufAuxiliar);
return size;
}
}else{
free(sizeStr);
return -1;
}
}
int socket_recv_string(int clientSocket, char** text){
return socket_recv(clientSocket, (void**)text, 1);
}
int socket_recv_int(int clientSocket, int* value){
char* sizeStr = malloc(sizeof(char)*11);
if (recv(clientSocket, sizeStr, 11, MSG_WAITALL) == 11){
*value = atoi(sizeStr);
free(sizeStr);
return sizeof(int);
}
free(sizeStr);
return -1;
}
|
/* -----------------------------------------------------------------------------
Filename: v_cfg.h
Description: Toolversion: 02.01.13.01.10.01.32.00.00.00
Serial Number: CBD1100132
Customer Info: BEIQI Foton Motor Co., Ltd.
Foton
Microcontroller: Infineon TriCore TC1767
Compiler: Tasking V3.3r1
Generator Fwk : GENy
Generator Module: GenTool_GenyVcfgNameDecorator
Configuration : D:\TaskingTc&GENywork\R1556\BMS_R1556\Bsw\Can\configCAN\configGENy\R1556.gny
ECU:
TargetSystem: Hw_TricoreCpu
Compiler: Tasking
Derivates: INFINEON_TC1767
Channel "Channel0":
Databasefile: D:\DBC WORK\R1556\R1556_Veh_02.dbc
Bussystem: CAN
Manufacturer: Vector
Node: Bcu
Channel "Channel1":
Databasefile: D:\DBC WORK\R1556\R1556_Inter_02.dbc
Bussystem: CAN
Manufacturer: Vector
Node: Bcu
Generated by , 2015-12-25 17:24:00
----------------------------------------------------------------------------- */
/* -----------------------------------------------------------------------------
C O P Y R I G H T
-------------------------------------------------------------------------------
Copyright (c) 2001-2008 by Vector Informatik GmbH. All rights reserved.
This software is copyright protected and proprietary to Vector Informatik
GmbH.
Vector Informatik GmbH grants to you only those rights as set out in the
license conditions.
All other rights remain with Vector Informatik GmbH.
-------------------------------------------------------------------------------
----------------------------------------------------------------------------- */
#if !defined(__V_CFG_H__)
#define __V_CFG_H__
#ifndef VGEN_GENY
#define VGEN_GENY
#endif
#ifndef GENy
#define GENy
#endif
#ifndef SUPPLIER_CANBEDDED
#define SUPPLIER_CANBEDDED 30
#endif
/* -----------------------------------------------------------------------------
&&&~ General Switches
----------------------------------------------------------------------------- */
#ifndef V_OSTYPE_NONE
#define V_OSTYPE_NONE
#endif
/* -----------------------------------------------------------------------------
&&&~ Processor specific
----------------------------------------------------------------------------- */
#ifndef C_CPUTYPE_32BIT
#define C_CPUTYPE_32BIT
#endif
#ifndef V_CPUTYPE_BITARRAY_32BIT
#define V_CPUTYPE_BITARRAY_32BIT
#endif
#ifndef C_CPUTYPE_LITTLEENDIAN
#define C_CPUTYPE_LITTLEENDIAN
#endif
#ifndef C_CPUTYPE_BITORDER_LSB2MSB
#define C_CPUTYPE_BITORDER_LSB2MSB
#endif
#ifndef V_DISABLE_USE_DUMMY_FUNCTIONS
#define V_DISABLE_USE_DUMMY_FUNCTIONS
#endif
#ifndef V_ENABLE_USE_DUMMY_STATEMENT
#define V_ENABLE_USE_DUMMY_STATEMENT
#endif
#ifndef C_COMP_TASKING_TRICORE_MULTICAN
#define C_COMP_TASKING_TRICORE_MULTICAN
#endif
#ifndef V_CPU_TRICORE
#define V_CPU_TRICORE
#endif
#ifndef V_COMP_TASKING
#define V_COMP_TASKING
#endif
#ifndef V_COMP_TASKING_TRICORE
#define V_COMP_TASKING_TRICORE
#endif
#ifndef V_PROCESSOR_INFINEON_TC1767
#define V_PROCESSOR_INFINEON_TC1767
#endif
#ifndef C_PROCESSOR_INFINEON_TC1767
#define C_PROCESSOR_INFINEON_TC1767
#endif
/* -----------------------------------------------------------------------------
&&&~ Used Modules
----------------------------------------------------------------------------- */
#define VGEN_ENABLE_XCP
#ifndef VGEN_ENABLE_VSTDLIB
#define VGEN_ENABLE_VSTDLIB
#endif
#ifndef VSTD_ENABLE_DEFAULT_INTCTRL
#define VSTD_ENABLE_DEFAULT_INTCTRL
#endif
#ifndef VSTD_ENABLE_GLOBAL_LOCK
#define VSTD_ENABLE_GLOBAL_LOCK
#endif
#ifndef VSTD_DISABLE_DEBUG_SUPPORT
#define VSTD_DISABLE_DEBUG_SUPPORT
#endif
#ifndef VSTD_ENABLE_LIBRARY_FUNCTIONS
#define VSTD_ENABLE_LIBRARY_FUNCTIONS
#endif
#define VGEN_ENABLE_CAN_DRV
#define C_ENABLE_CAN_CHANNELS
#define V_BUSTYPE_CAN
#define VGEN_ENABLE_IL_VECTOR
#ifndef kVNumberOfIdentities
#define kVNumberOfIdentities 1
#endif
#ifndef tVIdentityMsk
#define tVIdentityMsk vuint8
#endif
#ifndef kVIdentityIdentity_0
#define kVIdentityIdentity_0 (vuint8) 0
#endif
#ifndef VSetActiveIdentity
#define VSetActiveIdentity(identityLog)
#endif
#ifndef V_ACTIVE_IDENTITY_MSK
#define V_ACTIVE_IDENTITY_MSK 1
#endif
#ifndef V_ACTIVE_IDENTITY_LOG
#define V_ACTIVE_IDENTITY_LOG 0
#endif
/* -----------------------------------------------------------------------------
&&&~ Optimization
----------------------------------------------------------------------------- */
#define V_ATOMIC_BIT_ACCESS_IN_BITFIELD STD_OFF
#define V_ATOMIC_VARIABLE_ACCESS 16
#ifndef C_CLIENT_VECTOR
#define C_CLIENT_VECTOR
#endif
#ifndef __Bcu__
#define __Bcu__
#endif
/* -----------------------------------------------------------------------------
&&&~ Compatibility defines for ComSetCurrentECU
----------------------------------------------------------------------------- */
#define kComNumberOfNodes kVNumberOfIdentities
#define ComSetCurrentECU VSetActiveIdentity
#define comMultipleECUCurrent vActiveIdentityLog
#define C_VERSION_REF_IMPLEMENTATION 0x150u
#ifndef VGEN_ENABLE_VSTDLIB
/* DrvCan__baseRi15 requires VSTDLIB */
#define VGEN_ENABLE_VSTDLIB
#endif
#ifndef VGEN_ENABLE_VSTDLIB
#define VGEN_ENABLE_VSTDLIB
#endif
/* begin Fileversion check */
#ifndef SKIP_MAGIC_NUMBER
#ifdef MAGIC_NUMBER
#if MAGIC_NUMBER != 210607152
#error "The magic number of the generated file <D:\workspace\R1556\v_cfg.h> is different. Please check time and date of generated files!"
#endif
#else
#define MAGIC_NUMBER 210607152
#endif /* MAGIC_NUMBER */
#endif /* SKIP_MAGIC_NUMBER */
/* end Fileversion check */
#endif /* __V_CFG_H__ */
|
#include "easy_usart.h"
void easy_uart_setup(uint32_t baudrate, uint32_t cpu_frequency)
{
uint32_t ubbr = caculate_ubbr(baudrate, cpu_frequency);
set_ubbr(ubbr);
set_send_character_size(DATA_8BIT);
UCSR0B = (RXEN | TXEN);
stdin = stdout = (FILE *)&full_stdio;
}
uint32_t caculate_ubbr(uint32_t baudrate, uint32_t cpu_frequency)
{
float ubbr = roundf( (float)cpu_frequency / ( 16 * baudrate) -1 );
return (uint32_t)ubbr;
}
void set_ubbr(uint32_t ubbr)
{
UBRR0H = (ubbr >> 8) & 0xFF;
UBRR0L = ubbr & 0xFF;
}
void set_send_character_size(uint8_t character_size)
{
UCSR0C |= character_size << 1;
}
int file_uart_tx(char ch, FILE *stream)
{
if (ch == '\n')
file_uart_tx('\r', stream);
while (!(UCSR0A & UDRE));
UDR0 = ch;
return 0;
}
int file_uart_rx(FILE *stream)
{
while (!(UCSR0A & RXC));
return UDR0;
}
|
/*********************************************************************************************************
**
** 中国软件开源组织
**
** 嵌入式实时操作系统
**
** SylixOS(TM) LW : long wing
**
** Copyright All Rights Reserved
**
**--------------文件信息--------------------------------------------------------------------------------
**
** 文 件 名: pciScan.c
**
** 创 建 人: Han.Hui (韩辉)
**
** 文件创建日期: 2013 年 10 月 01 日
**
** 描 述: PCI 总线自动扫描匹配的设备驱动程序.
*********************************************************************************************************/
#define __SYLIXOS_KERNEL
#include "../SylixOS/kernel/include/k_kernel.h"
#include "../SylixOS/system/include/s_system.h"
/*********************************************************************************************************
裁剪宏
*********************************************************************************************************/
#if (LW_CFG_DEVICE_EN > 0) && (LW_CFG_PCI_EN > 0)
#include "pciProc.h"
/*********************************************************************************************************
PCI 主控器
*********************************************************************************************************/
extern PCI_CONFIG *_G_p_pciConfig;
/*********************************************************************************************************
内部回调参数
*********************************************************************************************************/
typedef struct {
PCI_DEV_DRV_DESC *PSA_p_pdddTable;
UINT PSA_uiNum;
} PCI_SCAN_ARG;
/*********************************************************************************************************
** 函数名称: __pciScanCb
** 功能描述: PCI 扫描回调函数.
** 输 入 : iBus 总线号
** iSlot 插槽
** iFunc 功能
** p_psa 扫描参数
** 输 出 : ERROR_NONE
** 全局变量:
** 调用模块:
** API 函数
*********************************************************************************************************/
static INT __pciScanCb (INT iBus, INT iSlot, INT iFunc, PCI_SCAN_ARG *p_psa)
{
INT i;
UINT32 usVenDevId;
UINT16 usVendorId;
UINT16 usDeviceId;
API_PciConfigInDword(iBus, iSlot, iFunc, PCI_VENDOR_ID, &usVenDevId);
usVendorId = (UINT16)(usVenDevId & 0xffff);
usDeviceId = (UINT16)(usVenDevId >> 16);
for (i = 0; i < p_psa->PSA_uiNum; i++) {
if ((p_psa->PSA_p_pdddTable[i].PDDD_usVendorId == usVendorId) ||
(p_psa->PSA_p_pdddTable[i].PDDD_usVendorId == 0xffff)) {
if ((p_psa->PSA_p_pdddTable[i].PDDD_usDeviceId == usDeviceId) ||
(p_psa->PSA_p_pdddTable[i].PDDD_usDeviceId == 0xffff)) {
if (p_psa->PSA_p_pdddTable[i].PDDD_pfuncDrv) {
p_psa->PSA_p_pdddTable[i].PDDD_pfuncDrv(iBus, iSlot, iFunc,
p_psa->PSA_p_pdddTable[i].PDDD_pvArg);
}
}
}
}
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: API_PciConfigInit
** 功能描述: 扫描所有 PCI 设备并且与给定的驱动程序表进行匹配, 如果允许, 则自动安装驱动程序.
** 输 入 : p_pdddTable 驱动程序表
** uiNum 驱动程序表大小
** 输 出 : ERROR or OK
** 全局变量:
** 调用模块:
** API 函数
*********************************************************************************************************/
LW_API
INT API_PciScan (PCI_DEV_DRV_DESC *p_pdddTable, UINT uiNum)
{
PCI_SCAN_ARG psa;
if (_G_p_pciConfig == LW_NULL) {
_ErrorHandle(ENOSYS);
return (PX_ERROR);
}
#if LW_CFG_PROCFS_EN > 0
__procFsPciInit();
#endif /* LW_CFG_PROCFS_EN > 0 */
if (!p_pdddTable || !uiNum) {
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
psa.PSA_p_pdddTable = p_pdddTable;
psa.PSA_uiNum = uiNum;
return (API_PciTraversalDev(0, LW_TRUE, __pciScanCb, &psa));
}
#endif /* (LW_CFG_DEVICE_EN > 0) && */
/* (LW_CFG_PCI_EN > 0) */
/*********************************************************************************************************
END
*********************************************************************************************************/
|
#include <stdio.h>
int my_strcmp(const char *s1, const char *s2)
{
int i = 0;
fprintf(stdout, "s1 : %s\n", s1);
fprintf(stdout, "s2 : %s\n", s2);
while (*s1 == *s2++)
{
fprintf(stdout, "count : %d\n", i);
fprintf(stdout, "s1 : %c\n", *s1);
fprintf(stdout, "s2 : %c\n", *s2);
if (*s1++ == '\0')
{
return 0;
}
i++;
}
return(*s1 - * (s2-1));
}
int main(int argc, char const *argv[])
{
int res;
if (argc < 2)
{
fprintf(stdout, "Few argc error\n");
return 1;
}
res = my_strcmp(argv[1], argv[2]);
fprintf(stdout, "%d\n", res);
return 0;
}
|
#include <stdio.h>
#define bool int
#define false 0
#define true 1
int isPowerOfThree(int n)
{
if(n == 1)
return true;
else if(n == 0)
return false;
else if(n % 3 == 0)
return isPowerOfThree(n / 3);
else
return false;
}
int main(int argc,const int **argv[])
{
int nums;
scanf("%d",&nums);
printf("\n %d \n",isPowerOfThree(nums));
}
|
#ifndef lint
static char *sccsid = "@(#)sg.c 1.8 ULTRIX 3/3/87";
#endif lint
/************************************************************************
* *
* Copyright (c) 1985, 86 by *
* Digital Equipment Corporation, Maynard, MA *
* All rights reserved. *
* *
* This software is furnished under a license and may be used and *
* copied only in accordance with the terms of such license and *
* with the inclusion of the above copyright notice. This *
* software or any other copies thereof may not be provided or *
* otherwise made available to any other person. No title to and *
* ownership of the software is hereby transferred. *
* *
* This software is derived from software received from the *
* University of California, Berkeley, and from Bell *
* Laboratories. Use, duplication, or disclosure is subject to *
* restrictions under license agreements with University of *
* California and with AT&T. *
* *
* The information in this software is subject to change without *
* notice and should not be construed as a commitment by Digital *
* Equipment Corporation. *
* *
* Digital assumes no responsibility for the use or reliability *
* of its software on equipment which is not supplied by Digital. *
* *
************************************************************************/
/***********************************************************************
*
* Modification History:
* 02-Mar-87 rafiey (Ali Rafieymehr)
* The video being turned off wasn't fixed correctly before.
*
* 11-Feb-87 rafiey (Ali Rafieymehr)
* Fixed a bug which was not turning the video on. Cleaned the code
* to include ioctls for the color support, and changed the chip
* select due to change of the hardware document and more cleanup.
*
* 07-Jan-87 rafiey (Ali Rafieymehr)
* Added the cursor to the driver and did some cleanup.
*
* 13-Dec-86 rafiey (Ali Rafieymehr)
* Converted the first pass color driver in to a semi-working
* version, which runs of the prototype VAXstar color board.
*
* 3-Sep-86 fred (Fred Canter)
* Make sure probe fails if CPU not a VAXstation 2200.
* Select video interrupt source (instead of sh driver).
*
* 2-Jul-86 rafiey (Ali Rafieymehr)
* Changed SGMAJOR to 50 and removed unused code.
*
* 18-Jun-86 rafiey (Ali Rafieymehr)
* Created this VAXstar color driver.
* Derived from qd.c.
*
**********************************************************************/
#if NSG > 0 || defined(BINARY)
#include "../data/sg_data.c" /* include external references to data file */
/*
* Following allow sgputc to function in
* the CPU in physical mode (during crash dump).
* One way transition, can't go back to virtual.
*/
#define VS_PHYSNEXUS 0x20080000
#define VS_PHYSBITMAP 0x30000000
#define VS_PHYSCURSOR 0x3c000400
int sg_physmode = 0;
/*
* Definitions needed to access the VAXstar SLU.
* Couldn't include sreg.h (too many compiler errors).
*/
#define sscsr nb_sercsr
#define ssrbuf nb_serrbuf_lpr
#define sslpr nb_serrbuf_lpr
#define sstcr nb_sertcr.c[0]
#define sstbuf nb_sermsr_tdr.c[0]
#define SS_TRDY 0x8000 /* Transmit ready */
#define SS_RDONE 0x80 /* Receiver done */
#define SS_PE 0x1000 /* Parity error */
#define SS_FE 0x2000 /* Framing error */
#define SS_DO 0x4000 /* Data overrun error */
#define SINT_ST 0100 /* SLU xmit interrupt bit */
/*
* VAXstar (color option) register address offsets from start of VAXstar (color)
* address space.
*/
#define ADDER 0x0000 /* ADDER chip address */
#define FCC 0x0200 /* Fifo Compression Chip address */
#define VDAC 0x0300 /* Video DAC address */
#define CUR 0x0400 /* CURsor chip address */
#define VRBACK 0x0500 /* Video ReadBACK address */
#define FIFORAM 0x8000 /* FIFO/template RAM */
/*
* general defines
*/
#define SGPRIOR (PZERO-1) /* must be negative */
#define FALSE 0
#define TRUE 1
#define CHAR_S 0xc7
#define CHAR_Q 0xc1
struct uba_device *sgdinfo[NSG];
struct mouse_report last_rep;
extern struct mouse_report current_rep; /* now in ss.c */
extern struct tty sm_tty; /* now in ss.c */
extern struct tty ss_tty[];
struct tty sg_tty[NSG*4];
int nsg = NSG*4;
/*
* macro to create a system virtual page number from system virtual adrs
*/
#define VTOP(x) (((int)x & ~0xC0000000) >> PGSHIFT) /* convert address */
/* to system page # */
/*
* Definition of the driver for the auto-configuration program.
*/
int sgprobe(), sgattach(), sgfint(), sgaint(), sgiint();
u_short sgstd[] = { 0 };
struct uba_driver sgdriver =
{ sgprobe, 0, sgattach, 0, sgstd, "sg", sgdinfo };
struct sg_fifo_space SG_bufmap[];
/*
* v_consputc is the switch that is used to redirect the console cnputc to the
* virtual console vputc.
* v_consgetc is the switch that is used to redirect the console getchar to the
* virtual console vgetc.
*/
extern (*v_consputc)();
extern (*v_consgetc)();
#define CONSOLEMAJOR 0
/*
* Keyboard state
*/
struct sg_keyboard {
int shift; /* state variables */
int cntrl;
int lock;
int hold;
char last; /* last character */
} sg_keyboard;
short sg_divdefaults[15] = { LK_DOWN, /* 0 doesn't exist */
LK_AUTODOWN, LK_AUTODOWN, LK_AUTODOWN, LK_DOWN,
LK_UPDOWN, LK_UPDOWN, LK_AUTODOWN, LK_AUTODOWN,
LK_AUTODOWN, LK_AUTODOWN, LK_AUTODOWN, LK_AUTODOWN,
LK_DOWN, LK_AUTODOWN };
short sg_kbdinitstring[] = { /* reset any random keyboard stuff */
LK_AR_ENABLE, /* we want autorepeat by default */
LK_CL_ENABLE, /* keyclick */
0x84, /* keyclick volume */
LK_KBD_ENABLE, /* the keyboard itself */
LK_BELL_ENABLE, /* keyboard bell */
0x84, /* bell volume */
LK_LED_DISABLE, /* keyboard leds */
LED_ALL };
#define KBD_INIT_LENGTH sizeof(sg_kbdinitstring)/sizeof(short)
#define TOY ((time.tv_sec * 100) + (time.tv_usec / 10000))
int sg_ipl_lo = 1; /* IPL low flag */
extern u_short sm_pointer_id; /* id of pointer device (mouse,tablet)-ss.c */
u_short sg_mouseon = 0; /* Mouse is enable when 1 */
u_short sg_open = 0; /* graphics device is open when 1 */
u_short sg_cur_reg = 0; /* Register to keep track of cursor register bits*/
u_short sgdebug = 0; /* Debug is enable when #0 */
char *sg_fifo_addr;
char *sg_ptr;
u_short req_length;
u_short int_flag = -1;
u_short nbytes_req, nbytes_left;
struct proc *rsel; /* process waiting for select */
int sgstart(), sgputc(), sggetc(), ttrstrt();
/*
* Keyboard translation and font tables
*/
extern char q_key[],q_shift_key[],*q_special[],q_font[];
extern struct nexus nexus[];
/*
* Default cursor (plane A and plane B)
*
*/
unsigned short def_cur[32] = {
/* plane A */ 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF,
0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF,
/* plane B */ 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF,
0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF
};
/*
* Default colors for the VDAC
*/
unsigned short def_vdac_colors[16] = {
/* BLACK */ VDAC_BLACK,
/* BLUE */ VDAC_BLUE,
/* GREEN */ VDAC_GREEN,
/* CYAN */ VDAC_CYAN,
/* RED */ VDAC_RED,
/* MAGENTA */ VDAC_MAGENTA,
/* YELLOW */ VDAC_YELLOW,
/* WHITE */ VDAC_WHITE,
/* GREY_1 */ VDAC_GREY_1,
/* GREY_2 */ VDAC_GREY_2,
/* GREY_3 */ VDAC_GREY_3,
/* GREY_4 */ VDAC_GREY_4,
/* GREY_5 */ VDAC_GREY_5,
/* GREY_6 */ VDAC_GREY_6,
/* GREY_7 */ VDAC_GREY_7,
/* GREY_8 */ VDAC_GREY_8
};
/******************************************************************
** **
** Routine to see if the graphic device will interrupt. **
** **
******************************************************************/
sgprobe(reg)
caddr_t reg;
{
register struct nb_regs *sgaddr = (struct nb_regs *)nexus;
register struct nb3_regs *sgaddr3 = (struct nb3_regs *)sgmem;
register struct fcc *sgfcc;
register struct vdac *sgvdac;
/*
* Only on a VAXstation 2200 (not MicroVAX 2000)
*/
if ((cpu != MVAX_II) ||
(cpu_subtype != ST_VAXSTAR) ||
(vs_cfgtst&VS_MULTU))
return(0);
/*
* Only if color option present
*/
if ((vs_cfgtst&VS_VIDOPT) == 0)
return(0);
sgaddr->nb_vdc_sel = 1; /* select color option interrupts */
sgaddr->nb_int_reqclr = SINT_VF;
sgaddr->nb_int_msk |= SINT_VF;
if (v_consputc != sgputc) {
sgbase = (caddr_t) ((u_long)sgaddr3);
sgmap.adder = sgbase + ADDER;
sgmap.fcc = sgbase + FCC;
sgmap.vdac = sgbase + VDAC;
sgmap.cur = sgbase + CUR;
sgmap.vrback = sgbase + VRBACK;
sgmap.fiforam = sgbase + FIFORAM;
sgvdac = (struct vdac *) sgmap.vdac;
sgvdac-> mode = 0x47;
cursor.x = 0;
cursor.y = 0;
sg_init_shared(); /* init shared memory */
}
sgfcc = (struct fcc *) sgmap.fcc;
/*
* Initialize the FCC by issuing HALT command (bits 9, 10 cbcsr to zero)
*/
*(u_long *) &sgfcc->cbcsr = (u_long) HALT;
/* Enable FIFO compression interrupt */
/* set fcc to display list mode */
sgaddr->nb_int_msk |= SINT_VS;
sgfcc->cbcsr &= ~FLUSH;
sgfcc->thresh = 0x100;
*(unsigned long *) &sgfcc->cbcsr |= (unsigned long)(((sgfcc->icsr|ENTHRSH) << 16)|DL_ENB);
DELAY(20000); /* wait */
if (cvec && cvec != 0x200)
cvec -= 4;
return(8);
}
/******************************************************************
** **
** Routine to attach to the graphic device. **
** **
******************************************************************/
sgattach(ui)
struct uba_device *ui;
{
register int *pte;
int i;
sg_keyboard.hold = 0; /* "Hold Screen" key is pressed if 1 */
/*
* init "sgflags"
*/
sgflags.inuse = 0; /* init inuse variable EARLY! */
sgflags.mapped = 0;
sgflags.kernel_loop = 0;
sgflags.user_fifo = 0;
sgflags.curs_acc = ACC_OFF;
sgflags.curs_thr = 128;
sgflags.tab_res = 2; /* default tablet resolution factor */
sgflags.duart_imask = 0; /* init shadow variables */
sgflags.adder_ie = 0;
/*
* init structures used in kbd/mouse interrupt routine. This code must
* come after the "sg_init_shared()" routine has run since that routine inits
* the eq_header structure used here.
*/
/* init the "latest mouse report" structure */
last_rep.state = 0;
last_rep.dx = 0;
last_rep.dy = 0;
last_rep.bytcnt = 0;
/* init the event queue (except mouse position) */
eq_header->header.events = (struct _vs_event *)
((int)eq_header + sizeof(struct sginput));
eq_header->header.size = MAXEVENTS;
eq_header->header.head = 0;
eq_header->header.tail = 0;
/* init single process access lock switch */
sg_open = 0;
/*
* Do the following only for the color display.
*/
if (v_consputc == sgputc) {
/*
* Map the bitmap for use by users.
*/
pte = (int *)(SGMEMmap[0]);
for( i=0 ; i<192 ; i++, pte++ )
*pte = (*pte & ~PG_PROT) | PG_UW | PG_V;
}
}
/******************************************************************
** **
** Routine to open the graphic device. **
** **
******************************************************************/
extern struct pdma sspdma[];
extern int ssparam();
/*ARGSUSED*/
sgopen(dev, flag)
dev_t dev;
{
register int unit = minor(dev);
register struct tty *tp;
register struct nb_regs *sgiaddr = (struct nb_regs *)nexus;
register struct vdac *sgvdac;
register struct fcc *sgfcc;
sgvdac = (struct vdac *)sgmap.vdac;
sgfcc = (struct fcc *) sgmap.fcc;
/*
* The graphics device can be open only by one person
*/
if (unit == 1) {
if (sg_open != 0)
return(EBUSY);
else
sg_open = 1;
sgflags.inuse |= GRAPHIC_DEV; /* graphics dev is open */
} else {
sgflags.inuse |= CONS_DEV; /* mark console as open */
}
if ((unit == 2) && (major(dev) == CONSOLEMAJOR))
tp = &sm_tty;
else
tp = &ss_tty[unit];
if (tp->t_state&TS_XCLUDE && u.u_uid!=0)
return (EBUSY);
tp->t_addr = (caddr_t)&sspdma[unit];
tp->t_oproc = sgstart;
if ((tp->t_state&TS_ISOPEN) == 0) {
ttychars(tp);
tp->t_state = TS_ISOPEN|TS_CARR_ON;
tp->t_ispeed = B4800;
tp->t_ospeed = B4800;
if( unit == 0 )
tp->t_flags = XTABS|EVENP|ECHO|CRMOD;
else
tp->t_flags = RAW;
if(tp != &sm_tty)
ssparam(unit);
}
sgiaddr->nb_int_msk |= SINT_VS; /* enable interrupts */
/*
* Process line discipline specific open if its not the mouse.
*/
if (unit != 1)
return ((*linesw[tp->t_line].l_open)(dev, tp));
else {
sg_mouseon = 1;
return(0);
}
}
/******************************************************************
** **
** Routine to close the graphic device. **
** **
******************************************************************/
/*ARGSUSED*/
sgclose(dev, flag)
dev_t dev;
int flag;
{
register struct tty *tp;
register int unit = minor(dev);
unit = minor(dev);
if ((unit == 2) && (major(dev) == CONSOLEMAJOR))
tp = &sm_tty;
else
tp = &ss_tty[unit];
/*
* If unit is not the mouse call the line disc. otherwise clear the state
* flag, and put the keyboard into down/up.
*/
if( unit != 1 ){
(*linesw[tp->t_line].l_close)(tp);
ttyclose(tp);
sgflags.inuse &= ~CONS_DEV;
} else {
sg_mouseon = 0;
if (sg_open != 1)
return(EBUSY);
else
sg_open = 0; /* mark the graphics device available */
sgflags.inuse &= ~GRAPHIC_DEV;
}
tp->t_state = 0;
}
/******************************************************************
** **
** Routine to read from the graphic device. **
** **
******************************************************************/
extern sg_strategy();
sgread(dev, uio)
dev_t dev;
struct uio *uio;
{
register struct tty *tp;
register int minor_dev;
register int unit;
minor_dev = minor(dev);
unit = (minor_dev >> 2) & 0x07;
/* If this is the console... */
if ((minor_dev & 0x03) != 1 &&
sgflags.inuse & CONS_DEV) {
if ((minor_dev == 2) && (major(dev) == CONSOLEMAJOR))
tp = &sm_tty;
else
tp = &ss_tty[minor_dev];
return ((*linesw[tp->t_line].l_read)(tp, uio));
}
/*
* else this must be a FIFO xfer from user space
*/
else if (sgflags.inuse & GRAPHIC_DEV) {
return (physio(sg_strategy, &sgbuf[unit],
dev, B_READ, minphys, uio));
}
}
/******************************************************************
** **
** Routine to write to the graphic device. **
** **
******************************************************************/
extern sg_strategy();
sgwrite(dev, uio)
dev_t dev;
struct uio *uio;
{
register struct tty *tp;
register int minor_dev;
register int unit;
minor_dev = minor(dev);
unit = (minor_dev >> 2) & 0x07;
/* If this is the console... */
if ((minor_dev & 0x03) != 1 &&
sgflags.inuse & CONS_DEV) {
if ((minor_dev == 2) && (major(dev) == CONSOLEMAJOR))
tp = &sm_tty;
else
tp = &ss_tty[minor_dev];
return ((*linesw[tp->t_line].l_write)(tp, uio));
}
/*
* else this must be a FIFO xfer from user space
*/
else if (sgflags.inuse & GRAPHIC_DEV) {
return (physio(sg_strategy, &sgbuf[unit],
dev, B_WRITE, minphys, uio));
}
}
/******************************************************************
** **
** Strategy routine to do FIFO **
** **
******************************************************************/
sg_strategy(bp)
register struct buf *bp;
{
register int npf, o;
register struct pte *pte;
register struct pte *mpte;
register struct proc *rp;
register struct fcc *sgfcc;
register struct adder *sgaddr;
register u_short *bufp;
int s;
int unit, i;
unsigned v;
unit = (minor(bp->b_dev) >> 2) & 0x07;
s = spl5();
/*
* following code figures out the proper ptes to
* remap into system space so interrupt routine can
* copy into buf structure.
*/
v = btop(bp->b_un.b_addr);
o = (int)bp->b_un.b_addr & PGOFSET;
npf = btoc(bp->b_bcount + o);
rp = bp->b_flags&B_DIRTY ? &proc[2] : bp->b_proc;
if ((bp->b_flags & B_PHYS) == 0)
{
sg_fifo_addr = bp->b_un.b_addr;
}
else {
if (bp->b_flags & B_UAREA)
pte = &rp->p_addr[v];
else if (bp->b_flags & B_PAGET)
pte = &Usrptmap[btokmx((struct pte *)bp->b_un.b_addr)];
else if ((bp->b_flags & B_SMEM) && /* SHMEM */
((bp->b_flags & B_DIRTY) == 0))
pte = ((struct smem *)rp)->sm_ptaddr + v;
else {
pte = vtopte(rp, v);
}
sg_fifo_addr = (char *)((int)SG_bufmap + (int)o);
mpte = (struct pte *)sgbufmap;
for (i = 0; i< npf; i++) {
if(pte->pg_pfnum == 0)
panic("sg: zero pfn in pte");
*(int *)mpte++ = pte++->pg_pfnum | PG_V | PG_KW;
mtpr(TBIS, (char *) SG_bufmap + (i*NBPG));
}
*(int *)mpte = 0;
mtpr(TBIS, (char *)SG_bufmap + (i * NBPG));
}
sgfcc = (struct fcc *) sgmap.fcc;
sgaddr = (struct adder *) sgmap.adder;
sg_ptr = sgmap.fiforam;
sgflags.user_fifo = -1;
if (!(bp->b_flags & B_READ)) {
nbytes_req = bp->b_bcount;
bcopy(sg_fifo_addr, sg_ptr, 0x020);
sgfcc->put += 0x010;
sg_fifo_addr += 0x020;
sg_ptr += 0x020;
nbytes_left = nbytes_req - 0x020;
}
sgfcc->icsr |= ENTHRSH;
while (sgflags.user_fifo) {
sleep((caddr_t)&sgflags.user_fifo, SGPRIOR);
}
splx(s);
iodone(bp);
}
/******************************************************************
** **
** Mouse activity select routine. **
** **
******************************************************************/
sgselect(dev, rw)
dev_t dev;
{
register int s = spl5();
register int unit = minor(dev);
if (unit == 1)
switch(rw) {
case FREAD: /* event available */
if(!(ISEMPTY(eq_header))) {
splx(s);
return(1);
}
rsel = u.u_procp;
sgflags.selmask |= SEL_READ;
splx(s);
return(0);
case FWRITE: /* FIFO done? */
if (DMA_ISEMPTY(FIFOheader)) {
splx(s);
return(1); /* return "1" if FIFO is done */
}
rsel = u.u_procp;
sgflags.selmask |= SEL_WRITE;
splx(s);
return(0);
}
else
return( ttselect(dev, rw) );
}
/******************************************************************
** **
** Graphic device ioctl routine. **
** **
******************************************************************/
/*ARGSUSED*/
sgioctl(dev, cmd, data, flag)
dev_t dev;
int cmd;
register caddr_t data;
{
register int *ptep; /* page table entry pointer */
register int mapix; /* QMEMmap[] page table index */
register struct _vs_event *vep;
register struct tty *tp;
register struct color_cursor *pcc;
register struct adder *sgaddr;
register struct nb_regs *nbaddr = (struct nb_regs *)nexus;
struct sgmap *sg; /* pointer to device map struct */
struct adder *adder; /* ADDER reg structure pointer */
struct prgkbd *cmdbuf;
struct prg_cursor *curs;
struct _vs_cursor *pos;
struct devget *devget;
register int unit = minor(dev);
int error;
int s;
int i; /* SIGNED index */
int sbr; /* SBR variable (you silly boy) */
u_int ix;
short status;
short *shortp; /* generic pointer to a short */
char *chrp; /* generic character pointer */
short *temp; /* a pointer to template RAM */
/*
* service the VAXstar color device ioctl commands
*/
switch (cmd) {
case QD_MAPDEVICE:
sg = (struct sgmap *) &sgmap;
bcopy(sg, data, sizeof(struct sgmap));
break;
case QD_MAPCOLOR:
sgflags.mapped |= MAPCOLOR;
ptep = (int *) ((VTOP(color_buf) * 4)
+ (mfpr(SBR) | 0x80000000));
/* allow user write to color map write buffer */
*ptep++ = (*ptep & ~PG_PROT) | PG_UW | PG_V;
*ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V;
mtpr(TBIA, 0); /* clr CPU translation buf */
sgaddr = (struct adder *) sgmap.adder;
sgflags.adder_ie |= VSYNC;
sgaddr->interrupt_enable = sgflags.adder_ie;
*(int *)data = (int) color_buf;
break;
/*--------------------------------------------------------------
* unmap shared color map write buffer and kill VSYNC intrpts */
case QD_UNMAPCOLOR:
if (sgflags.mapped & MAPCOLOR) {
sgflags.mapped &= ~MAPCOLOR;
ptep = (int *) ((VTOP(color_buf) * 4)
+ (mfpr(SBR) | 0x80000000));
/* re-protect color map write buffer */
*ptep++ = (*ptep & ~PG_PROT) | PG_KW | PG_V;
*ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V;
mtpr(TBIA, 0); /* smash CPU's translation buf */
sgaddr = (struct adder *) sgmap.adder;
sgflags.adder_ie &= ~VSYNC;
sgaddr->interrupt_enable = sgflags.adder_ie;
}
break;
case QD_MAPSCROLL:
sgflags.mapped |= MAPSCR;
ptep = (int *) ((VTOP(scroll) * 4)
+ (mfpr(SBR) | 0x80000000));
/* allow user write to scroll area */
*ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V;
mtpr(TBIA, 0); /* clr CPU translation buf */
scroll->status = 0;
sgaddr = (struct adder *) sgmap.adder;
sgflags.adder_ie |= FRAME_SYNC;
sgaddr->interrupt_enable = sgflags.adder_ie;
*(int *)data = (int) scroll;
break;
/*-------------------------------------------------------------
* unmap shared scroll param area and disable scroll intrpts */
case QD_UNMAPSCROLL:
if (sgflags.mapped & MAPSCR) {
sgflags.mapped &= ~MAPSCR;
ptep = (int *) ((VTOP(scroll) * 4)
+ (mfpr(SBR) | 0x80000000));
/* re-protect 512 scroll param area */
*ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V;
mtpr(TBIA, 0); /* smash CPU's translation buf */
sgaddr = (struct adder *) sgmap.adder;
sgflags.adder_ie &= ~FRAME_SYNC;
sgaddr->interrupt_enable = sgflags.adder_ie;
}
break;
/*---------------------------------------------
* give user write access to the event queue */
case QD_MAPEVENT:
sgflags.mapped |= MAPEQ;
ptep = (int *) ((VTOP(eq_header) * 4)
+ (mfpr(SBR) | 0x80000000));
/* allow user write to 1K event queue */
*ptep++ = (*ptep & ~PG_PROT) | PG_UW | PG_V;
*ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V;
mtpr(TBIA, 0); /* clr CPU translation buf */
/* return event queue address */
*(int *)data = (int) eq_header;
break;
/*-------------------------------------
* do setup for FIFO by user process */
case QD_MAPIOBUF:
/*------------------------------------------------
* set 'user write enable' bits for FIFO buffer */
sgflags.mapped |= MAPFIFO;
ptep = (int *) ((VTOP(FIFOheader) * 4)
+ (mfpr(SBR) | 0x80000000));
for (i = (FIFObuf_size >> PGSHIFT); i > 0; --i)
*ptep++ = (*ptep & ~PG_PROT) | PG_UW | PG_V;
mtpr(TBIA, 0); /* clr CPU translation buf */
/*----------------------
* return I/O buf adr */
*(int *)data = (int) FIFOheader;
break;
case QD_RDCONFIG:
break;
case QD_GETEVENT: /* extract the oldest event from event queue */
if (ISEMPTY(eq_header)) {
vep = (struct _vs_event *) data;
vep->vse_device = VSE_NULL;
break;
}
vep = (struct _vs_event *) GETBEGIN(eq_header);
s = spl5();
GETEND(eq_header);
splx(s);
bcopy(vep, data, sizeof(struct _vs_event));
break;
case QD_RESET: /* init the dragon, DUART, and driver variables */
sg_init_shared(); /* init shared memory */
sg_setup_dragon(); /* init the ADDER/VIPER stuff */
sg_clr_screen();
sg_load_cursor( def_cur); /* load default cursor map */
sg_ld_font(); /* load the console font */
break;
case QD_SET: /* init the DUART and driver variables */
sg_init_shared();
break;
case QD_CLRSCRN: /* clear the screen. This reinits the dragon */
sg_setup_dragon();
sg_clr_screen();
break;
case QD_WTCURSOR: /* load a cursor into template RAM */
sg_load_cursor(data);
break;
/* case QD_RDCURSOR:
break;
*/
case QD_POSCURSOR: /* position the mouse cursor */
pos = (struct _vs_cursor *) data;
pcc = (struct color_cursor *) sgmap.cur;
s = spl5();
pcc->xpos = CURS_MIN_X + pos->x;
pcc->ypos = CURS_MIN_Y + pos->y;
eq_header->curs_pos.x = pos->x;
eq_header->curs_pos.y = pos->y;
splx(s);
break;
/*--------------------------------------
* set the cursor acceleration factor */
case QD_PRGCURSOR:
curs = (struct prg_cursor *) data;
s = spl5();
sgflags.curs_acc = curs->acc_factor;
sgflags.curs_thr = curs->threshold;
splx(s);
break;
/*--------------------------------------
* pass caller's programming commands to LK201 */
case QD_PRGKBD:
cmdbuf = (struct prgkbd *)data; /* pnt to kbd cmd buf */
sg_key_out (cmdbuf->cmd);
/*
* Send param1?
*/
if (cmdbuf->cmd & LAST_PARAM)
break;
sg_key_out (cmdbuf->param1);
/*
* Send param2?
*/
if (cmdbuf->param1 & LAST_PARAM)
break;
sg_key_out (cmdbuf->param2);
break;
/*--------------------------------------
* pass caller's programming commands to mouse */
case QD_PRGMOUSE:
break;
case QD_KERN_LOOP: /* redirect kernel messages */
sgflags.kernel_loop = -1;
break;
case QD_KERN_UNLOOP: /* don't redirect kernel messages */
sgflags.kernel_loop = 0;
break;
case QD_PRGTABRES: /* program the tablet resolution factor*/
sgflags.tab_res = *(short *)data;
break;
case DEVIOCGET: /* device status */
devget = (struct devget *)data;
bzero(devget,sizeof(struct devget));
devget->category = DEV_TERMINAL;
devget->bus = DEV_QB;
bcopy(DEV_VCB02,devget->interface,
strlen(DEV_VCB02));
if(unit == 0)
bcopy(DEV_VR290,devget->device,
strlen(DEV_VR290)); /* terminal */
else if(sm_pointer_id == MOUSE_ID)
bcopy(DEV_MOUSE,devget->device,
strlen(DEV_MOUSE));
else if(sm_pointer_id == TABLET_ID)
bcopy(DEV_TABLET,devget->device,
strlen(DEV_TABLET));
else
bcopy(DEV_UNKNOWN,devget->device,
strlen(DEV_UNKNOWN));
devget->adpt_num = 0; /* no adapter*/
devget->nexus_num = 0; /* fake nexus 0 */
devget->bus_num = 0; /* No bus */
devget->ctlr_num = 0; /* cntlr number */
devget->slave_num = unit; /* which line */
bcopy("sg", devget->dev_name, 3); /* Ultrix "sg" */
devget->unit_num = unit; /* sg line? */
devget->soft_count = 0; /* soft er. cnt.*/
devget->hard_count = 0; /* hard er cnt. */
devget->stat = 0; /* status */
devget->category_stat = 0; /* cat. stat. */
break;
default:
tp = &ss_tty[unit];
error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag);
if (error >= 0)
return(error);
error = ttioctl(tp, cmd, data, flag);
if (error >= 0)
return(error);
break;
}
return(0);
}
/******************************************************************
** **
** ADDER interrupt routine. **
** **
******************************************************************/
sgaint(sg)
register int sg;
{
register struct adder *sgaddr;
register struct fcc *sgfcc;
register struct nb_regs *nbaddr = (struct nb_regs *)nexus;
register struct vdac *sgvdac;
struct color_buf *cbuf;
short status;
int i;
register struct rgb *rgbp;
spl4(); /* allow interval timer in */
sgaddr = (struct adder *) sgmap.adder;
sgfcc = (struct fcc *) sgmap.fcc;
/*
* service the vertical blank interrupt (VSYNC bit) by loading any pending
* color map load request
*/
if (sgaddr->status & ADDRESS_COMPLETE) {
if (sgflags.adder_ie & ADDRESS_COMPLETE) {
sgfcc->cbcsr |= FLUSH;
if (sgfcc->fwused > 0) {
bcopy(sg_ptr, sg_fifo_addr, sgfcc->fwused*2);
sgfcc->get += sgfcc->fwused;
sg_fifo_addr += (sgfcc->fwused * 2);
sg_ptr += (sgfcc->fwused * 2);
}
sgflags.adder_ie &= ~ADDRESS_COMPLETE;
sgaddr->interrupt_enable = sgflags.adder_ie;
while (!(sgfcc->cbcsr & IDLE));
if (sgfcc->fwused > 0) {
bcopy(sg_ptr, sg_fifo_addr, sgfcc->fwused*2);
sgfcc->get += sgfcc->fwused;
sg_fifo_addr += (sgfcc->fwused * 2);
sg_ptr += (sgfcc->fwused * 2);
}
if (sgflags.user_fifo) {
sgflags.user_fifo = 0;
wakeup((caddr_t)&sgflags.user_fifo);
}
sgfcc->cbcsr = (short) HALT;
}
}
if (sgaddr->status & VSYNC) {
sgaddr->status &= ~VSYNC; /* clear the interrupt */
cbuf = color_buf;
if (cbuf->status & LOAD_COLOR_MAP) {
sgvdac = (struct vdac *) sgmap.vdac;
for (i = cbuf->count, rgbp = cbuf->rgb; --i >= 0; rgbp++) {
status = rgbp->green << 8;
status |= (rgbp->blue << 4);
status |= rgbp->red;
sgvdac->a_color_map[rgbp->offset] = status;
}
cbuf->status &= ~LOAD_COLOR_MAP;
}
}
/*
* service the scroll interrupt (FRAME_SYNC bit)
*/
if (sgaddr->status & FRAME_SYNC) {
sgaddr->status &= ~FRAME_SYNC; /* clear the interrupt */
if (scroll->status & LOAD_REGS) {
for ( i = 1000, sgaddr->status = 0
; i > 0 && !((status = sgaddr->status)
& ID_SCROLL_READY)
; --i);
if (i == 0) {
cprintf("\nsg: sgaint: timeout on ID_SCROLL_READY");
return;
}
sgaddr->ID_scroll_data = scroll->viper_constant;
sgaddr->ID_scroll_command = ID_LOAD | SCROLL_CONSTANT;
sgaddr->y_scroll_constant = scroll->y_scroll_constant;
sgaddr->y_offset_pending = scroll->y_offset;
if (scroll->status & LOAD_INDEX) {
sgaddr->x_index_pending = scroll->x_index_pending;
sgaddr->y_index_pending = scroll->y_index_pending;
}
scroll->status = 0x00;
}
}
}
/******************************************************************
** **
** FCC (FIFO) interrupt routine. **
** **
******************************************************************/
sgfint(sg)
int sg;
{
register struct fcc *sgfcc;
register struct adder *sgaddr;
register struct FIFOreq_header *header;
register struct FIFOreq *request;
int unit;
u_short csr;
u_short *sgfifo;
u_short *temp;
spl4();
unit = sg<<2;
header = FIFOheader;
sgfcc = (struct fcc *) sgmap.fcc;
sgaddr = (struct adder *) sgmap.adder;
if (int_flag == -1) {
if (DMA_ISIGNORE(header)) {
DMA_CLRIGNORE(header);
return;
}
}
if (sgflags.user_fifo == -1) {
csr = sgfcc->cbcsr;
if ((csr & PTB_ENB) == PTB_ENB) {
if (nbytes_left > 0) {
bcopy(sg_fifo_addr, sg_ptr, nbytes_left);
sgfcc->put += (nbytes_left / 2);
sg_fifo_addr += nbytes_left;
sg_ptr += nbytes_left;
nbytes_left -= nbytes_left;
if (sgfcc->fwused < sgfcc->thresh)
sgfcc->thresh = sgfcc->fwused;
sgfcc->icsr &= ~ENTHRSH;
sgfcc->icsr |= ENIDLE;
sgfcc->cbcsr |= FLUSH;
} else {
sg_wait_status(sgaddr, ADDRESS_COMPLETE);
if (sgflags.user_fifo) {
sgflags.user_fifo = 0;
wakeup((caddr_t)&sgflags.user_fifo);
}
sgfcc->cbcsr = (short) HALT;
}
} else {
if ((csr & BTP_ENB) == BTP_ENB) {
loop:
if (sgfcc->fwused > 512) {
bcopy(sg_ptr, sg_fifo_addr, 1024);
sgfcc->get += 512;
sg_fifo_addr += 1024;
sg_ptr += 1024;
}
else {
bcopy(sg_ptr, sg_fifo_addr, sgfcc->fwused*2);
sgfcc->get += sgfcc->fwused;
sg_fifo_addr += (sgfcc->fwused * 2);
sg_ptr += (sgfcc->fwused * 2);
}
if (sgfcc->fwused > sgfcc->thresh) goto loop;
sgflags.adder_ie |= ADDRESS_COMPLETE;
sgaddr->interrupt_enable = sgflags.adder_ie;
}
}
} else {
if (int_flag == -1) {
if (DMA_ISFULL(header)) {
if (rsel && sgflags.selmask & SEL_WRITE) {
selwakeup(rsel, 0);
rsel = 0;
sgflags.selmask &= ~SEL_WRITE;
}
}
if (DMA_ISEMPTY(header))
return;
}
request = FIFO_GETBEGIN(header);
if (request->FIFOtype == DISPLIST) {
temp = (u_short *)request->bufp;
req_length = request->length;
if (req_length > 0) {
bcopy(temp, sgmap.fiforam, request->length);
sgfcc->put += (request->length / 2);
if (sgfcc->fwused < sgfcc->thresh)
sgfcc->thresh = sgfcc->fwused;
sgfcc->icsr &= ~ITHRESH;
request->length = 0;
req_length = 0;
int_flag = 0;
return;
} else {
/* sg_wait_status(sgaddr, ADDRESS_COMPLETE);*/
sgfcc->icsr &= ~ENTHRSH;
sgfcc->icsr &= ~ITHRESH;
int_flag = -1;
}
} else {
mprintf("\nsg: sgfint: illegal FIFOtype\n");
DMA_CLRACTIVE(header);
return;
}
DMA_GETEND(header);
if (DMA_ISEMPTY(header)) {
if (rsel && sgflags.selmask & SEL_WRITE) {
selwakeup(rsel, 0);
rsel = 0;
sgflags.selmask &= ~SEL_WRITE;
}
DMA_CLRACTIVE(header);
return;
}
*(unsigned long *) &sgfcc->cbcsr = (unsigned long) 0;
*(unsigned long *) &sgfcc->put = (unsigned long ) 0;
sgfcc->thresh = 0x0000;
*(unsigned long *)&sgfcc->cbcsr |= (unsigned long)(((sgfcc->icsr|ENTHRSH)<<16)|DL_ENB);
}
}
/******************************************************************
** **
** Graphic device input interrupt Routine. **
** **
******************************************************************/
sgiint(ch)
register int ch;
{
register struct _vs_event *vep;
register struct sginput *eqh;
register struct color_cursor *sgcursor;
struct mouse_report *new_rep;
struct tty *tp;
register int unit;
register c;
register int i, j;
u_short data;
char wakeup_flag = 0; /* flag to do a select wakeup call */
int cnt;
/*
* Mouse state info
*/
static char temp, old_switch, new_switch;
eqh = eq_header;
unit = (ch>>8)&03;
new_rep = ¤t_rep;
tp = &ss_tty[unit];
/*
* If graphic device is turned on
*/
if (sg_mouseon == 1) {
cnt = 0;
while (cnt++ == 0) {
/*
* Pick up LK-201 input (if any)
*/
if (unit == 0) {
/* event queue full ? */
if (ISFULL(eqh) == TRUE) {
cprintf("\nsg0: sgiint: event queue overflow");
return(0);
}
/*
* Get a character.
*/
data = ch & 0xff;
/*
* Check for various keyboard errors
*/
if( data == LK_POWER_ERROR || data == LK_KDOWN_ERROR ||
data == LK_INPUT_ERROR || data == LK_OUTPUT_ERROR) {
cprintf("\nsg0: sgiint: keyboard error, code = %x",data);
return(0);
}
if (data < LK_LOWEST)
return(0);
++wakeup_flag; /* request a select wakeup call */
vep = PUTBEGIN(eqh);
PUTEND(eqh);
/*
* Check for special case in which "Hold Screen" key is pressed. If so, treat is
* as if ^s or ^q was typed.
*/
if (data == HOLD) {
vep->vse_direction = VSE_KBTRAW;
vep->vse_type = VSE_BUTTON;
vep->vse_device = VSE_DKB;
vep->vse_x = eqh->curs_pos.x;
vep->vse_y = eqh->curs_pos.y;
vep->vse_time = TOY;
vep->vse_key = CNTRL; /* send CTRL */
vep = PUTBEGIN(eqh);
PUTEND(eqh);
vep->vse_direction = VSE_KBTRAW;
vep->vse_type = VSE_BUTTON;
vep->vse_device = VSE_DKB;
vep->vse_x = eqh->curs_pos.x;
vep->vse_y = eqh->curs_pos.y;
vep->vse_time = TOY;
if( sg_keyboard.hold == 0) {
if((tp->t_state & TS_TTSTOP) == 0) {
vep->vse_key = CHAR_S; /* send character "s" */
sg_key_out( LK_LED_ENABLE );
sg_key_out(LED_4);
sg_keyboard.hold = 1;
tp->t_state |= TS_TTSTOP;
}
else {
vep->vse_key = CHAR_Q; /* send character "q" */
tp->t_state &= ~TS_TTSTOP;
}
}
else {
vep->vse_key = CHAR_Q; /* send character "q" */
sg_key_out( LK_LED_DISABLE );
sg_key_out( LED_4 );
sg_keyboard.hold = 0;
tp->t_state &= ~TS_TTSTOP;
}
vep = PUTBEGIN(eqh);
PUTEND(eqh);
vep->vse_direction = VSE_KBTRAW;
vep->vse_type = VSE_BUTTON;
vep->vse_device = VSE_DKB;
vep->vse_x = eqh->curs_pos.x;
vep->vse_y = eqh->curs_pos.y;
vep->vse_time = TOY;
vep->vse_key = ALLUP;
}
else {
if (sg_keyboard.cntrl == 1) {
switch (data) {
case CHAR_S:
tp->t_state |= TS_TTSTOP;
break;
case CHAR_Q:
sg_key_out( LK_LED_DISABLE );
sg_key_out( LED_4 );
sg_keyboard.hold = 0;
tp->t_state &= ~TS_TTSTOP;
break;
default:
sg_keyboard.cntrl = 0;
}
}
vep->vse_direction = VSE_KBTRAW;
vep->vse_type = VSE_BUTTON;
vep->vse_device = VSE_DKB;
vep->vse_x = eqh->curs_pos.x;
vep->vse_y = eqh->curs_pos.y;
vep->vse_time = TOY;
vep->vse_key = data;
if (data == CNTRL)
sg_keyboard.cntrl = 1;
}
}
/*
* Pick up the mouse input (if any)
*/
if ((unit == 1) && (sm_pointer_id == MOUSE_ID)) {
/* event queue full ? */
if (ISFULL(eqh) == TRUE) {
cprintf("\nsg0: sgiint: event queue overflow");
return(0);
}
/*
* see if mouse position has changed
*/
if( new_rep->dx != 0 || new_rep->dy != 0) {
/*
* Check to see if we have to accelerate the mouse
*
*/
if (sgflags.curs_acc > ACC_OFF) {
if (new_rep->dx >= sgflags.curs_thr)
new_rep->dx +=
(new_rep->dx - sgflags.curs_thr) * sgflags.curs_acc;
if (new_rep->dy >= sgflags.curs_thr)
new_rep->dy +=
(new_rep->dy - sgflags.curs_thr) * sgflags.curs_acc;
}
/*
* update mouse position
*/
if( new_rep->state & X_SIGN) {
eqh->curs_pos.x += new_rep->dx;
if( eqh->curs_pos.x > MAX_CUR_X )
eqh->curs_pos.x = MAX_CUR_X;
}
else {
eqh->curs_pos.x -= new_rep->dx;
if( eqh->curs_pos.x < -15 )
eqh->curs_pos.x = -15;
}
if( new_rep->state & Y_SIGN) {
eqh->curs_pos.y -= new_rep->dy;
if( eqh->curs_pos.y < -15 )
eqh->curs_pos.y = -15;
}
else {
eqh->curs_pos.y += new_rep->dy;
if( eqh->curs_pos.y > MAX_CUR_Y )
eqh->curs_pos.y = MAX_CUR_Y;
}
if( tp->t_state & TS_ISOPEN ) {
sgcursor = (struct color_cursor *) sgmap.cur;
sgcursor->xpos = CURS_MIN_X + eqh->curs_pos.x;
sgcursor->ypos = CURS_MIN_Y + eqh->curs_pos.y;
}
if (eqh->curs_pos.y <= eqh->curs_box.bottom &&
eqh->curs_pos.y >= eqh->curs_box.top &&
eqh->curs_pos.x <= eqh->curs_box.right &&
eqh->curs_pos.x >= eqh->curs_box.left) goto mbuttons;
vep = PUTBEGIN(eqh);
PUTEND(eqh);
++wakeup_flag; /* request a select wakeup call */
/*
* Put event into queue and do select
*/
vep->vse_x = eqh->curs_pos.x;
vep->vse_y = eqh->curs_pos.y;
vep->vse_device = VSE_MOUSE; /* mouse */
vep->vse_type = VSE_MMOTION; /* position changed */
vep->vse_time = TOY; /* time stamp */
vep->vse_direction = 0;
vep->vse_key = 0;
}
/*
* See if mouse buttons have changed.
*/
mbuttons:
new_switch = new_rep->state & 0x07;
old_switch = last_rep.state & 0x07;
temp = old_switch ^ new_switch;
if( temp ) {
for (j = 1; j < 8; j <<= 1) {/* check each button */
if (!(j & temp)) /* did this button change? */
continue;
/* event queue full? */
if (ISFULL(eqh) == TRUE) {
cprintf("\nsg0: sgiint: event queue overflow");
return(0);
}
vep = PUTBEGIN(eqh); /* get new event */
PUTEND(eqh);
++wakeup_flag; /* request a select wakeup call */
/* put event into queue */
switch (j) {
case RIGHT_BUTTON:
vep->vse_key = VSE_RIGHT_BUTTON;
break;
case MIDDLE_BUTTON:
vep->vse_key = VSE_MIDDLE_BUTTON;
break;
case LEFT_BUTTON:
vep->vse_key = VSE_LEFT_BUTTON;
break;
}
if (new_switch & j)
vep->vse_direction = VSE_KBTDOWN;
else
vep->vse_direction = VSE_KBTUP;
vep->vse_type = VSE_BUTTON;
vep->vse_device = VSE_MOUSE; /* mouse */
vep->vse_time = TOY;
vep->vse_x = eqh->curs_pos.x;
vep->vse_y = eqh->curs_pos.y;
}
/* update the last report */
last_rep = current_rep;
}
} /* Pick up mouse input */
else if ((unit == 1) && (sm_pointer_id == TABLET_ID)) {
/* event queue full? */
if (ISFULL(eqh) == TRUE) {
cprintf("\nsg0: sgiint: event queue overflow");
return(0);
}
/* update cursor position coordinates */
new_rep->dx /= sgflags.tab_res;
new_rep->dy = (2200 - new_rep->dy) / sgflags.tab_res;
if( new_rep->dx > MAX_CUR_X )
new_rep->dx = MAX_CUR_X;
if( new_rep->dy > MAX_CUR_Y )
new_rep->dy = MAX_CUR_Y;
/*
* see if the puck/stylus has moved
*/
if( eqh->curs_pos.x != new_rep->dx ||
eqh->curs_pos.y != new_rep->dy) {
/*
* update cursor position
*/
eqh->curs_pos.x = new_rep->dx;
eqh->curs_pos.y = new_rep->dy;
if( tp->t_state & TS_ISOPEN ) {
sgcursor = (struct color_cursor *) sgmap.cur;
sgcursor->xpos = CURS_MIN_X + eqh->curs_pos.x;
sgcursor->ypos = CURS_MIN_Y + eqh->curs_pos.y;
}
if (eqh->curs_pos.y < eqh->curs_box.bottom &&
eqh->curs_pos.y >= eqh->curs_box.top &&
eqh->curs_pos.x < eqh->curs_box.right &&
eqh->curs_pos.x >= eqh->curs_box.left) goto tbuttons;
vep = PUTBEGIN(eqh);
PUTEND(eqh);
++wakeup_flag; /* request a select wakeup call */
/* Put event into queue */
/*
* The type should be "VSE_TMOTION" but, the X doesn't know this type, therefore
* until X is fixed, we fake it to be "VSE_MMOTION".
*
*/
vep->vse_type = VSE_MMOTION;
vep->vse_device = VSE_TABLET; /* tablet */
vep->vse_direction = 0;
vep->vse_x = eqh->curs_pos.x;
vep->vse_y = eqh->curs_pos.y;
vep->vse_key = 0;
vep->vse_time = TOY;
}
/*
* See if tablet buttons have changed.
*/
tbuttons:
new_switch = new_rep->state & 0x1e;
old_switch = last_rep.state & 0x1e;
temp = old_switch ^ new_switch;
if( temp ) {
/* event queue full? */
if (ISFULL(eqh) == TRUE) {
cprintf("\nsg0: sgiint: event queue overflow");
return(0);
}
vep = PUTBEGIN(eqh);
PUTEND(eqh);
++wakeup_flag; /* request a select wakeup call */
/* put event into queue */
vep->vse_device = VSE_TABLET; /* tablet */
vep->vse_type = VSE_BUTTON;
vep->vse_x = eqh->curs_pos.x;
vep->vse_y = eqh->curs_pos.y;
vep->vse_time = TOY;
/* define the changed button and if up or down */
for (j = 1; j <= 0x10; j <<= 1) {/* check each button */
if (!(j & temp)) /* did this button change? */
continue;
switch (j) {
case T_RIGHT_BUTTON:
vep->vse_key = VSE_T_RIGHT_BUTTON;
break;
case T_FRONT_BUTTON:
vep->vse_key = VSE_T_FRONT_BUTTON;
break;
case T_BACK_BUTTON:
vep->vse_key = VSE_T_BACK_BUTTON;
break;
case T_LEFT_BUTTON:
vep->vse_key = VSE_T_LEFT_BUTTON;
break;
}
if (new_switch & j)
vep->vse_direction = VSE_KBTDOWN;
else
vep->vse_direction = VSE_KBTUP;
}
/* update the last report */
last_rep = current_rep;
}
} /* Pick up tablet input */
} /* While input available */
/*
* If we have proc waiting, and event has happened, wake him up
*/
if(rsel && wakeup_flag && sgflags.selmask & SEL_READ) {
selwakeup(rsel,0);
rsel = 0;
sgflags.selmask &= ~SEL_READ;
wakeup_flag = 0;
}
}
/*
* If the graphic device is not turned on, this is console input
*/
else {
/*
* Get a character from the keyboard.
*/
if (ch & 0100000) {
data = ch & 0xff;
/*
* Check for various keyboard errors
*/
if( data == LK_POWER_ERROR || data == LK_KDOWN_ERROR ||
data == LK_INPUT_ERROR || data == LK_OUTPUT_ERROR) {
cprintf("sg0: sgiint: Keyboard error, code = %x\n",data);
return(0);
}
if( data < LK_LOWEST ) return(0);
/*
* See if its a state change key
*/
switch ( data ) {
case LOCK:
sg_keyboard.lock ^= 0xffff; /* toggle */
if( sg_keyboard.lock )
sg_key_out( LK_LED_ENABLE );
else
sg_key_out( LK_LED_DISABLE );
sg_key_out( LED_3 );
return;
case SHIFT:
sg_keyboard.shift ^= 0xffff;
return;
case CNTRL:
sg_keyboard.cntrl ^= 0xffff;
return;
case ALLUP:
sg_keyboard.cntrl = sg_keyboard.shift = 0;
return;
case REPEAT:
c = sg_keyboard.last;
break;
case HOLD:
/*
* "Hold Screen" key was pressed, we treat it as if ^s or ^q was typed.
*/
if (sg_keyboard.hold == 0) {
if((tp->t_state & TS_TTSTOP) == 0) {
c = q_key[CHAR_S];
sg_key_out( LK_LED_ENABLE );
sg_key_out( LED_4 );
sg_keyboard.hold = 1;
} else
c = q_key[CHAR_Q];
}
else {
c = q_key[CHAR_Q];
sg_key_out( LK_LED_DISABLE );
sg_key_out( LED_4 );
sg_keyboard.hold = 0;
}
if( c >= ' ' && c <= '~' )
c &= 0x1f;
(*linesw[tp->t_line].l_rint)(c, tp);
return;
default:
/*
* Test for control characters. If set, see if the character
* is elligible to become a control character.
*/
if( sg_keyboard.cntrl ) {
c = q_key[ data ];
if( c >= ' ' && c <= '~' )
c &= 0x1f;
} else if( sg_keyboard.lock || sg_keyboard.shift )
c = q_shift_key[ data ];
else
c = q_key[ data ];
break;
}
sg_keyboard.last = c;
/*
* Check for special function keys
*/
if( c & 0x80 ) {
register char *string;
string = q_special[ c & 0x7f ];
while( *string )
(*linesw[tp->t_line].l_rint)(*string++, tp);
} else
(*linesw[tp->t_line].l_rint)(c, tp);
if (sg_keyboard.hold &&((tp->t_state & TS_TTSTOP) == 0)) {
sg_key_out( LK_LED_DISABLE );
sg_key_out( LED_4 );
sg_keyboard.hold = 0;
}
}
}
return(0);
}
/******************************************************************
** **
** Routine to start transmission. **
** **
******************************************************************/
sgstart(tp)
register struct tty *tp;
{
register int unit, c;
register struct tty *tp0;
int s;
unit = minor(tp->t_dev);
tp0 = &sm_tty;
unit &= 03;
s = spl5();
/*
* If it's currently active, or delaying, no need to do anything.
*/
if (tp->t_state&(TS_TIMEOUT|TS_BUSY|TS_TTSTOP))
goto out;
/*
* Display chars until the queue is empty, if the second subchannel is open
* direct them there. Drop characters from any lines other than 0 on the floor.
*/
while( tp->t_outq.c_cc ) {
c = getc(&tp->t_outq);
if (unit == 0) {
if (tp0->t_state & TS_ISOPEN)
(*linesw[tp0->t_line].l_rint)(c, tp0);
else
sg_blitc( c & 0xff );
}
}
/*
* If there are sleepers, and output has drained below low
* water mark, wake up the sleepers.
*/
if ( tp->t_outq.c_cc<=TTLOWAT(tp) )
if (tp->t_state&TS_ASLEEP){
tp->t_state &= ~TS_ASLEEP;
wakeup((caddr_t)&tp->t_outq);
}
tp->t_state &= ~TS_BUSY;
out:
splx(s);
}
/******************************************************************
** **
** Routine to stop output on the graphic device, e.g. for ^S/^Q **
** or output flush. **
** **
******************************************************************/
/*ARGSUSED*/
sgstop(tp, flag)
register struct tty *tp;
{
register int s;
/*
* Block interrupts while modifying the state.
*/
s = spl5();
if (tp->t_state & TS_BUSY)
if ((tp->t_state&TS_TTSTOP)==0)
tp->t_state |= TS_FLUSH;
else
tp->t_state &= ~TS_BUSY;
splx(s);
}
/******************************************************************
** **
** Routine to output a character to the screen **
** **
******************************************************************/
sg_blitc( c )
register char c;
{
register struct adder *sgaddr;
register struct color_cursor *sgcursor;
register int i;
/*
* initialize ADDER
*/
sgaddr = (struct adder *) sgmap.adder;
sgcursor = (struct color_cursor *) sgmap.cur;
c &= 0x7f;
switch ( c ) {
case '\t': /* tab */
for (i = 8 - ((cursor.x >> 3) & 0x07); i > 0; --i) {
sg_blitc( ' ' );
}
return(0);
case '\r': /* return */
cursor.x = 0;
sgcursor->xpos = CURS_MIN_X + cursor.x;
return(0);
case '\b': /* backspace */
if (cursor.x > 0) {
cursor.x -= CHAR_WIDTH;
sg_blitc( ' ' );
cursor.x -= CHAR_WIDTH;
sgcursor->xpos = CURS_MIN_X + cursor.x;
}
return(0);
case '\n': /* linefeed */
if ((cursor.y += CHAR_HEIGHT) > (MAX_CUR_Y - CHAR_HEIGHT)) {
if (sg_mouseon == 1)
cursor.y = 0;
else {
cursor.y -= CHAR_HEIGHT;
sg_scroll_up(sgaddr);
}
}
sgcursor->ypos = CURS_MIN_Y + cursor.y;
return(0);
default:
if( c < ' ' || c > '~' )
return(0);
}
/*
* setup VIPER operand control registers
*/
sg_write_id(sgaddr, CS_UPDATE_MASK, 0x0001); /* select plane #0 */
sg_write_id(sgaddr, SRC1_OCR_B,
EXT_NONE | INT_SOURCE | ID | BAR_SHIFT_DELAY);
sg_write_id(sgaddr, CS_UPDATE_MASK, 0x000E); /* select other planes */
sg_write_id(sgaddr, SRC1_OCR_B,
EXT_SOURCE | INT_NONE | NO_ID | BAR_SHIFT_DELAY);
sg_write_id(sgaddr, CS_UPDATE_MASK, 0x000F); /* select all planes */
sg_write_id(sgaddr, DST_OCR_B,
EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);
sg_write_id(sgaddr, MASK_1, 0xFFFF);
sg_write_id(sgaddr, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 1);
sg_write_id(sgaddr, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);
/*
* load DESTINATION origin and vectors
*/
sgaddr->fast_dest_dy = 0;
sgaddr->slow_dest_dx = 0;
sgaddr->error_1 = 0;
sgaddr->error_2 = 0;
sgaddr->rasterop_mode = DST_WRITE_ENABLE | NORMAL;
sg_wait_status(sgaddr, RASTEROP_COMPLETE);
sgaddr->destination_x = cursor.x;
sgaddr->fast_dest_dx = CHAR_WIDTH;
sgaddr->destination_y = cursor.y;
sgaddr->slow_dest_dy = CHAR_HEIGHT;
/*
* load SOURCE origin and vectors
*/
sgaddr->source_1_x = FONT_X + ((c - ' ') * CHAR_WIDTH);
sgaddr->source_1_y = FONT_Y;
sgaddr->source_1_dx = CHAR_WIDTH;
sgaddr->source_1_dy = CHAR_HEIGHT;
sg_write_id(sgaddr, LU_FUNCTION_R1, FULL_SRC_RESOLUTION | LF_SOURCE);
sgaddr->cmd = RASTEROP | OCRB | 0 | S1E | DTE;
/*
* update console cursor coordinates */
cursor.x += CHAR_WIDTH;
sgcursor->xpos = CURS_MIN_X + cursor.x;
if (cursor.x > (MAX_CUR_X - CHAR_WIDTH)) {
sg_blitc( '\r' );
sg_blitc( '\n' );
}
}
/********************************************************************
** **
** Routine to direct kernel console output to display destination **
** **
********************************************************************/
sgputc( c )
register char c;
{
register struct tty *tp0;
/*
* This routine may be called in physical mode by the dump code
* so we change the driver into physical mode.
* One way change, can't go back to virtual mode.
*/
if( (mfpr(MAPEN) & 1) == 0 ) {
sg_physmode = 1;
sg_mouseon = 0;
sg_blitc(c & 0xff);
return;
}
/*
* direct kernel output char to the proper place
*/
tp0 = &sm_tty;
if (sgflags.kernel_loop != 0 && tp0->t_state & TS_ISOPEN) {
(*linesw[tp0->t_line].l_rint)(c, tp0);
} else {
sg_blitc(c & 0xff);
}
}
/******************************************************************
** **
** Routine to get a character from LK201. **
** **
******************************************************************/
sggetc()
{
int c;
u_short data;
/*
* Get a character from the keyboard,
*/
loop:
data = ssgetc();
/*
* Check for various keyboard errors
*/
if( data == LK_POWER_ERROR || data == LK_KDOWN_ERROR ||
data == LK_INPUT_ERROR || data == LK_OUTPUT_ERROR) {
cprintf(" sg0: Keyboard error, code = %x\n",data);
return(0);
}
if( data < LK_LOWEST ) return(0);
/*
* See if its a state change key
*/
switch ( data ) {
case LOCK:
sg_keyboard.lock ^= 0xffff; /* toggle */
if( sg_keyboard.lock )
sg_key_out( LK_LED_ENABLE );
else
sg_key_out( LK_LED_DISABLE );
sg_key_out( LED_3 );
goto loop;
case SHIFT:
sg_keyboard.shift ^= 0xffff;
goto loop;
case CNTRL:
sg_keyboard.cntrl ^= 0xffff;
goto loop;
case ALLUP:
sg_keyboard.cntrl = sg_keyboard.shift = 0;
goto loop;
case REPEAT:
c = sg_keyboard.last;
break;
default:
/*
* Test for control characters. If set, see if the character
* is elligible to become a control character.
*/
if( sg_keyboard.cntrl ) {
c = q_key[ data ];
if( c >= ' ' && c <= '~' )
c &= 0x1f;
} else if( sg_keyboard.lock || sg_keyboard.shift )
c = q_shift_key[ data ];
else
c = q_key[ data ];
break;
}
sg_keyboard.last = c;
/*
* Check for special function keys
*/
if( c & 0x80 )
return (0);
else
return (c);
}
/*********************************************************************
** **
** Routine to initialize virtual console. This routine sets up the **
** graphic device so that it can be used as the system console. It **
** is invoked before autoconfig and has to do everything necessary **
** to allow the device to serve as the system console. **
** **
*********************************************************************/
extern (*vs_gdopen)();
extern (*vs_gdclose)();
extern (*vs_gdread)();
extern (*vs_gdwrite)();
extern (*vs_gdselect)();
extern (*vs_gdkint)();
extern (*vs_gdioctl)();
extern (*vs_gdstop)();
sgcons_init()
{
register struct nb_regs *ssaddr = (struct nb_regs *)nexus;
register struct nb3_regs *sgaddr = (struct nb3_regs *)sgmem;
register struct nb1_regs *sgaddr1 = (struct nb1_regs *)qmem;
register struct vdac *sgvdac;
register struct color_cursor *sgcursor;
/*
* Set the line parameters on SLU line 0 for
* the LK201 keyboard: 4800 BPS, 8-bit char, 1 stop bit, no parity.
*/
ssaddr->sslpr = (SER_RXENAB | SER_KBD | SER_SPEED | SER_CHARW);
/*
* Load sgmap structure with the virtual addresses of the VAXstar (color).
*/
sgbase = (caddr_t) ((u_long)sgaddr);
sgmap.adder = sgbase + ADDER;
sgmap.fcc = sgbase + FCC;
sgmap.vdac = sgbase + VDAC;
sgmap.cur = sgbase + CUR;
sgmap.vrback = sgbase + VRBACK;
sgmap.fiforam = sgbase + FIFORAM;
sgvdac = (struct vdac *) sgmap.vdac;
sgvdac-> mode = 0x47;
sgcursor = (struct color_cursor *)sgmap.cur;
sg_cur_reg = (VBHI | ENRG1 | ENPA | ENPB);
sgcursor->cmdr = sg_cur_reg;
sgcursor->xmin1 = 0;
sgcursor->xmax1 = MAX_CUR_X;
sgcursor->ymin1 = 0;
sgcursor->ymax1 = MAX_CUR_Y;
/*
* Initialize the VAXstar (color)
*/
cursor.x = 0;
cursor.y = 0;
sg_init_shared(); /* init shared memory */
sg_setup_dragon(); /* init ADDR/VIPER */
sg_clr_screen(); /* clear the screen */
sg_ld_font(); /* load the console font */
sg_load_cursor(def_cur); /* load default cursor */
sg_input(); /* init the input devices */
v_consputc = sgputc;
v_consgetc = sggetc;
vs_gdopen = sgopen;
vs_gdclose = sgclose;
vs_gdread = sgread;
vs_gdwrite = sgwrite;
vs_gdselect = sgselect;
vs_gdkint = sgiint;
vs_gdioctl = sgioctl;
vs_gdstop = sgstop;
}
sgreset()
{
}
/******************************************************************
** **
** Routine to setup the input devices **
** (keyboard, mouse, and tablet). **
** **
******************************************************************/
sg_input()
{
register struct nb_regs *ssaddr = (struct nb_regs *)nexus;
register int lpr;
int i;
int status;
char id_byte;
/*
* Set the line parameters on SLU line 0 for
* the LK201 keyboard: 4800 BPS, 8-bit char, 1 stop bit, no parity.
*/
ssaddr->sslpr = (SER_RXENAB | SER_KBD | SER_SPEED | SER_CHARW);
/*
* Reset the keyboard to the default state
*/
sg_key_out(LK_DEFAULTS);
/*
* Set SLU line 1 parameters for mouse communication.
*/
lpr = SER_POINTER | SER_CHARW | SER_PARENB | SER_ODDPAR
| SER_SPEED | SER_RXENAB;
ssaddr->sslpr = lpr;
/*
* Perform a self-test
*/
sg_putc(SELF_TEST);
/*
* Wait for the first byte of the self-test report
*
*/
status = sg_getc();
if (status < 0) {
cprintf("\nsg: Timeout on 1st byte of self-test report\n");
goto OUT;
}
/*
* Wait for the hardware ID (the second byte returned by the self-test report)
*
*/
id_byte = sg_getc();
if (id_byte < 0) {
cprintf("\nsg: Timeout on 2nd byte of self-test report\n");
goto OUT;
}
/*
* Wait for the third byte returned by the self-test report)
*
*/
status = sg_getc();
if (status != 0) {
cprintf("\nsg: Timeout on 3rd byte of self-test report\n");
goto OUT;
}
/*
* Wait for the forth byte returned by the self-test report)
*
*/
status = sg_getc();
if (status != 0) {
cprintf("\nsg: Timeout on 4th byte of self-test report\n");
goto OUT;
}
/*
* Wait to be sure that the self-test is done (documentation indicates that
* it requires 1 second to do the self-test).
*/
DELAY(1000000);
/*
* Set the operating mode
*
* We set the mode for both mouse and the tablet to "Incremental stream mode".
*
*/
if ((id_byte & 0x0f) == MOUSE_ID)
sm_pointer_id = MOUSE_ID;
else
sm_pointer_id = TABLET_ID;
sg_putc(INCREMENTAL);
OUT:
return(0);
}
/******************************************************************
** **
** Routine to get 1 character from the mouse (SLU line 1). **
** Return an error on timeout or faulty character. **
** **
** NOTE: **
** This routine will be used just during initialization **
** (during system boot). **
** **
******************************************************************/
sg_getc()
{
register struct nb_regs *ssaddr = (struct nb_regs *)nexus;
register int timo;
register int c;
for(timo=50; timo > 0; --timo) {
DELAY(1000);
if(ssaddr->sscsr&SS_RDONE) {
c = ssaddr->ssrbuf;
if(((c >> 8) & 03) != 1)
continue;
if(c&(SS_DO|SS_FE|SS_PE))
continue;
return(c & 0xff);
}
}
return(-1);
}
/******************************************************************
** **
** Routine to send a character to the mouse using SLU line 1. **
** **
** NOTE: **
** This routine will be used just during initialization **
** (during system boot). **
** **
******************************************************************/
sg_putc(c)
register int c;
{
register struct nb_regs *ssaddr = (struct nb_regs *)nexus;
register int timo;
ssaddr->sstcr |= 0x2;
timo = 60000;
while ((ssaddr->sscsr&SS_TRDY) == 0)
if (--timo == 0)
break;
ssaddr->sstbuf = c&0xff;
DELAY(50000); /* ensure character transmit completed */
ssaddr->sstcr &= ~0x2;
}
/******************************************************************
** **
** Routine to load the cursor. **
** **
******************************************************************/
sg_load_cursor(data)
unsigned short data[32];
{
register struct color_cursor *cur;
register struct vdac *sgvdac;
register int i;
cur = (struct color_cursor *) sgmap.cur;
sgvdac = (struct vdac *) sgmap.vdac;
sg_cur_reg |= LODSA;
cur->cmdr = sg_cur_reg;
for (i = 0; i < 32; ++i)
cur->cmem = data[i];
sg_cur_reg &= ~LODSA;
cur->cmdr = sg_cur_reg;
}
/******************************************************************
** **
** Routine to output a character to the LK201 keyboard. This **
** routine polls the tramsmitter on the keyboard to output a **
** code. The timer is to avaoid hanging on a bad device. **
** **
******************************************************************/
sg_key_out( c )
char c;
{
register struct nb_regs *ssaddr;
register int timo = 30000;
int s;
int tcr, ln;
if (v_consputc != sgputc)
return;
if(sg_physmode)
ssaddr = (struct nb_regs *)VS_PHYSNEXUS;
else
ssaddr = (struct nb_regs *)nexus;
if(sg_physmode == 0)
s = spl5();
tcr = 0;
ssaddr->sstcr |= 1;
while (1) {
while ((ssaddr->sscsr&SS_TRDY) == 0 && timo--) ;
ln = (ssaddr->sscsr>>8) & 3;
if (ln != 0) {
tcr |= (1 << ln);
ssaddr->sstcr &= ~(1 << ln);
continue;
}
ssaddr->sstbuf = c&0xff;
while (1) {
while ((ssaddr->sscsr&SS_TRDY) == 0) ;
ln = (ssaddr->sscsr>>8) & 3;
if (ln != 0) {
tcr |= (1 << ln);
ssaddr->sstcr &= ~(1 << ln);
continue;
}
break;
}
ssaddr->sstcr &= ~0x1;
if (tcr == 0)
ssaddr->nb_int_reqclr = SINT_ST;
else
ssaddr->sstcr |= tcr;
break;
}
if(sg_physmode == 0)
splx(s);
}
/******************************************************************
** **
** Routine to write to the ID bus **
** **
******************************************************************/
sg_write_id(sgaddr, adrs, data)
register struct adder *sgaddr;
register short adrs;
register short data;
{
int i;
short status;
for ( i = 100000, sgaddr->status = 0
; i > 0 && !((status = sgaddr->status) &
ADDRESS_COMPLETE)
; --i);
if (i == 0)
goto ERR;
for ( i = 100000, sgaddr->status = 0
; i > 0 && !((status = sgaddr->status) &
TX_READY)
; --i);
if (i > 0) {
sgaddr->id_data = data;
sgaddr->command = ID_LOAD | adrs;
return(0);
}
ERR:
cprintf("\nsg_write_id: timeout trying to write to VIPER");
return(-1);
}
/******************************************************************
** **
** Routine to delay for at least one display frame time **
** **
******************************************************************/
sg_wait_status(sgaddr, mask)
register struct adder *sgaddr;
register int mask;
{
register short status;
int i;
for ( i = 10000, sgaddr->status = 0
; i > 0 && !((status = sgaddr->status) & mask)
; --i);
if (i == 0) {
cprintf("\nsg_wait_status: timeout polling for 0x%x in sgaddr->status", mask);
return(-1);
}
return(0);
}
/******************************************************************
** **
** Routine to initialize the shared memory **
** **
******************************************************************/
sg_init_shared()
{
register struct color_cursor *sgcursor;
sgcursor = (struct color_cursor *) sgmap.cur;
/*
* initialize the event queue pointers and header
*/
eq_header = (struct sginput *)
(((int)event_shared & ~(0x01FF)) + 512);
eq_header->curs_pos.x = 0;
eq_header->curs_pos.y = 0;
sgcursor->xpos = CURS_MIN_X + eq_header->curs_pos.x;
sgcursor->ypos = CURS_MIN_Y + eq_header->curs_pos.y;
eq_header->curs_box.left = 0;
eq_header->curs_box.right = 0;
eq_header->curs_box.top = 0;
eq_header->curs_box.bottom = 0;
/*
* assign a pointer to the FIFO I/O buffer for this QDSS.
*/
FIFOheader = (struct FIFOreq_header *)
((int)(&FIFO_shared[0] + 512) & ~0x1FF);
FIFOheader->FIFOreq = (struct FIFOreq *) ((int)FIFOheader
+ sizeof(struct FIFOreq_header));
FIFOheader->shared_size = FIFObuf_size;
FIFOheader->used = 0;
FIFOheader->size = 10; /* default = 10 requests */
FIFOheader->oldest = 0;
FIFOheader->newest = 0;
/*
* assign a pointer to the scroll structure.
*/
scroll = (struct scroll *)
((int)(&scroll_shared[0] + 512) & ~0x1FF);
scroll->status = 0;
scroll->viper_constant = 0;
scroll->y_scroll_constant = 0;
scroll->y_offset = 0;
scroll->x_index_pending = 0;
scroll->y_index_pending = 0;
/*
* assign a pointer to the color map write buffer
*/
color_buf = (struct color_buf *)
((int)(&color_shared[0] + 512) & ~0x1FF);
color_buf->status = 0;
color_buf->count = 0;
}
/******************************************************************
** **
** Routine to initialize the ADDER, VIPER, bitmaps, and color **
** map. **
** **
******************************************************************/
sg_setup_dragon()
{
register struct adder *sgaddr;
register struct vdac *sgvdac;
register short *color;
int i; /* general purpose variables */
int status;
short top; /* clipping/scrolling boundaries */
short bottom;
short right;
short left;
short *red; /* color map pointers */
short *green;
short *blue;
/*
* init for setup
*/
sgaddr = (struct adder *) sgmap.adder;
sgvdac = (struct vdac *) sgmap.vdac;
sgvdac-> mode = 0x47;
sgaddr->command = CANCEL;
/*
* set monitor timing
*/
sgaddr->x_scan_count_0 = 0x2800;
sgaddr->x_scan_count_1 = 0x1020;
/* sgaddr->x_scan_count_2 = 0x003E;*/
sgaddr->x_scan_count_2 = 0x003A;
sgaddr->x_scan_count_3 = 0x38F0;
sgaddr->x_scan_count_4 = 0x6128;
/* sgaddr->x_scan_count_5 = 0x093B;*/
sgaddr->x_scan_count_5 = 0x093A;
sgaddr->x_scan_count_6 = 0x313C;
sgaddr->x_scan_conf = 0x00C8;
/*
* got a bug in secound pass ADDER! lets take care of it
*/
/* normally, just use the code in the following bug fix code, but to
* make repeated demos look pretty, load the registers as if there was
* no bug and then test to see if we are getting sync
*/
sgaddr->y_scan_count_0 = 0x135F;
sgaddr->y_scan_count_1 = 0x3363;
sgaddr->y_scan_count_2 = 0x2366;
sgaddr->y_scan_count_3 = 0x0388;
/* if no sync, do the bug fix code */
if (sg_wait_status(sgaddr, FRAME_SYNC) == -1) {
/*
* first load all Y scan registers with very short frame and
* wait for scroll service. This guarantees at least one SYNC
* to fix the pass 2 Adder initialization bug (synchronizes
* XCINCH with DMSEEDH).
*/
sgaddr->y_scan_count_0 = 0x01;
sgaddr->y_scan_count_1 = 0x01;
sgaddr->y_scan_count_2 = 0x01;
sgaddr->y_scan_count_3 = 0x01;
sg_wait_status(sgaddr, FRAME_SYNC);
sg_wait_status(sgaddr, FRAME_SYNC);
/* now load the REAL sync values (in reverse order just to
* be safe.
*/
sgaddr->y_scan_count_3 = 0x0388;
sgaddr->y_scan_count_2 = 0x2366;
sgaddr->y_scan_count_1 = 0x3363;
sgaddr->y_scan_count_0 = 0x135F;
}
/*
* zero the index registers
*/
sgaddr->x_index_pending = 0;
sgaddr->y_index_pending = 0;
sgaddr->x_index_new = 0;
sgaddr->y_index_new = 0;
sgaddr->x_index_old = 0;
sgaddr->y_index_old = 0;
sgaddr->pause = 0;
/*
* set rasterop mode to normal pen down
*/
sgaddr->rasterop_mode = DST_WRITE_ENABLE | DST_INDEX_ENABLE | NORMAL;
/*
* set the rasterop registers to a default values
*/
sgaddr->source_1_dx = 1;
sgaddr->source_1_dy = 1;
sgaddr->source_1_x = 0;
sgaddr->source_1_y = 0;
sgaddr->destination_x = 0;
sgaddr->destination_y = 0;
sgaddr->fast_dest_dx = 1;
sgaddr->fast_dest_dy = 0;
sgaddr->slow_dest_dx = 0;
sgaddr->slow_dest_dy = 1;
sgaddr->error_1 = 0;
sgaddr->error_2 = 0;
/*
* scale factor = unity
*/
sgaddr->fast_scale = UNITY;
sgaddr->slow_scale = UNITY;
/*
* set the source 2 parameters
*/
sgaddr->source_2_x = 0;
sgaddr->source_2_y = 0;
sgaddr->source_2_size = 0x0022;
/*
* initialize plane addresses for four vipers
*/
sg_write_id(sgaddr, CS_UPDATE_MASK, 0x0001);
sg_write_id(sgaddr, PLANE_ADDRESS, 0x0000);
sg_write_id(sgaddr, CS_UPDATE_MASK, 0x0002);
sg_write_id(sgaddr, PLANE_ADDRESS, 0x0001);
sg_write_id(sgaddr, CS_UPDATE_MASK, 0x0004);
sg_write_id(sgaddr, PLANE_ADDRESS, 0x0002);
sg_write_id(sgaddr, CS_UPDATE_MASK, 0x0008);
sg_write_id(sgaddr, PLANE_ADDRESS, 0x0003);
/* initialize the external registers. */
sg_write_id(sgaddr, CS_UPDATE_MASK, 0x000F);
sg_write_id(sgaddr, CS_SCROLL_MASK, 0x000F);
/* initialize resolution mode */
sg_write_id(sgaddr, MEMORY_BUS_WIDTH, 0x000C); /* bus width = 16 */
sg_write_id(sgaddr, RESOLUTION_MODE, 0x0000); /* one bit/pixel */
/* initialize viper registers */
sg_write_id(sgaddr, SCROLL_CONSTANT, SCROLL_ENABLE|VIPER_LEFT|VIPER_UP);
sg_write_id(sgaddr, SCROLL_FILL, 0x0000);
/*
* set clipping and scrolling limits to full screen
*/
for ( i = 1000, sgaddr->status = 0
; i > 0 && !((status = sgaddr->status) &
ADDRESS_COMPLETE)
; --i);
if (i == 0)
cprintf("\nsg%d: sg_setup_dragon: timeout on ADDRESS_COMPLETE");
top = 0;
bottom = 2048;
left = 0;
right = 1024;
sgaddr->x_clip_min = left;
sgaddr->x_clip_max = right;
sgaddr->y_clip_min = top;
sgaddr->y_clip_max = bottom;
sgaddr->scroll_x_min = left;
sgaddr->scroll_x_max = right;
sgaddr->scroll_y_min = top;
sgaddr->scroll_y_max = bottom;
sg_wait_status(sgaddr, FRAME_SYNC);
sg_wait_status(sgaddr, FRAME_SYNC);
sgaddr->x_index_pending = left;
sgaddr->y_index_pending = top;
sgaddr->x_index_new = left;
sgaddr->y_index_new = top;
sgaddr->x_index_old = left;
sgaddr->y_index_old = top;
for ( i = 1000, sgaddr->status = 0
; i > 0 && !((status = sgaddr->status) &
ADDRESS_COMPLETE)
; --i);
if (i == 0)
cprintf("\nsg%d: sg_setup_dragon: timeout on ADDRESS_COMPLETE");
sg_write_id(sgaddr, LEFT_SCROLL_MASK, 0x0000);
sg_write_id(sgaddr, RIGHT_SCROLL_MASK, 0x0000);
/*
* set source and the mask register to all ones (ie: white)
*/
sg_write_id(sgaddr, SOURCE, 0xFFFF);
sg_write_id(sgaddr, MASK_1, 0xFFFF);
sg_write_id(sgaddr, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 15);
sg_write_id(sgaddr, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);
/*
* initialize Operand Control Register banks for fill command
*/
sg_write_id(sgaddr, SRC1_OCR_A, EXT_NONE | INT_M1_M2 | NO_ID | WAIT);
sg_write_id(sgaddr, SRC2_OCR_A, EXT_NONE | INT_SOURCE | NO_ID | NO_WAIT);
sg_write_id(sgaddr, DST_OCR_A, EXT_NONE | INT_NONE | NO_ID | NO_WAIT);
sg_write_id(sgaddr, SRC1_OCR_B, EXT_NONE | INT_SOURCE | NO_ID | WAIT);
sg_write_id(sgaddr, SRC2_OCR_B, EXT_NONE | INT_M1_M2 | NO_ID | NO_WAIT);
sg_write_id(sgaddr, DST_OCR_B, EXT_NONE | INT_NONE | NO_ID | NO_WAIT);
/*
* init Logic Unit Function registers, (these are just common values,
* and may be changed as required).
*/
sg_write_id(sgaddr, LU_FUNCTION_R1, FULL_SRC_RESOLUTION | LF_SOURCE);
sg_write_id(sgaddr, LU_FUNCTION_R2, FULL_SRC_RESOLUTION | LF_SOURCE | INV_M1_M2);
sg_write_id(sgaddr, LU_FUNCTION_R3, FULL_SRC_RESOLUTION | LF_D_OR_S);
sg_write_id(sgaddr, LU_FUNCTION_R4, FULL_SRC_RESOLUTION | LF_D_XOR_S);
/*
* load the color map
*/
/* sg_init_vdac();*/
/* sgvdac->mode = 0x42;*/
for ( i = 0, sgaddr->status = 0
; i < 10000 && !((status = sgaddr->status) &
FRAME_SYNC)
; ++i);
if (i == 0)
cprintf("\nsg%d: sg_setup_dragon: timeout on FRAME_SYNC");
sgvdac->a_color_map[0] = 0x0000; /* black */
sgvdac->a_color_map[1] = 0x0FFF; /* white */
/*
* set color map for mouse cursor
*/
sgvdac->b_cur_colorA = 0x0000; /* black */
sgvdac->b_cur_colorB = 0x0FFF; /* white */
return(0);
}
/******************************************************************
** **
** Routine to load eight basic colors into the color map and **
** eight grey scales as well **
** **
** **
** red green blue map location **
** -------------------- ------------ **
** black 00 | 00 | 00 0 **
** blue 00 | 00 | FF 1 **
** green 00 | FF | 00 2 **
** cyan 00 | FF | FF 3 **
** red FF | 00 | 00 4 **
** magenta FF | 00 | FF 5 **
** yellow FF | FF | 00 6 **
** white FF | FF | FF 7 **
** **
** grey_1 00 | 00 | 00 8 **
** grey_2 24 | 24 | 24 9 **
** grey_3 48 | 48 | 48 10 **
** grey_4 6C | 6C | 6C 11 **
** grey_5 90 | 90 | 90 12 **
** grey_6 B4 | B4 | B4 13 **
** grey_7 D8 | D8 | D8 14 **
** grey_8 FF | FF | FF 15 **
** **
******************************************************************/
sg_init_vdac()
{
register struct vdac *sgvdac;
register struct adder *sgaddr;
register int i;
sgvdac = (struct vdac *) sgmap.vdac;
sgaddr = (struct adder *) sgmap.adder;
for (i = 0; i < 16; i++)
sgvdac->a_color_map[i] = def_vdac_colors[i];
/* for (i = 0; i < 16; i++)
sgvdac->b_color_map[i] = def_vdac_colors[i];
*/
sgvdac->a_cur_colorA = VDAC_GREY_3;
sgvdac->a_cur_colorB = VDAC_GREY_6;
sgvdac->a_cur_colorC = VDAC_GREY_8;
sgvdac->b_cur_colorA = VDAC_GREY_3;
sgvdac->b_cur_colorB = VDAC_GREY_6;
sgvdac->b_cur_colorC = VDAC_GREY_8;
/* sgvdac->dadj_sync = 0x001A;
sgvdac->dadj_blank = 0x001A;
sgvdac->dadj_active = 0x001A;
*/
sg_wait_status(sgaddr, FRAME_SYNC);
/* for now */
sgvdac->mode = 0x0056;
}
/******************************************************************
** **
** Routine to clear the screen **
** **
** >>> NOTE <<< **
** **
** This code requires that certain adder initialization be **
** valid. To assure that this requirement is satisfied, this **
** routine should be called only after calling the **
** "sg_setup_dragon()" function. **
** Clear the bitmap a piece at a time. Since the fast scroll **
** clear only clears the current displayed portion of the **
** bitmap put a temporary value in the y limit register so we **
** can access whole bitmap. **
******************************************************************/
sg_clr_screen()
{
register struct adder *sgaddr;
sgaddr = (struct adder *) sgmap.adder;
sgaddr->x_limit = 1024;
sgaddr->y_limit = 2048 - CHAR_HEIGHT;
sgaddr->y_offset_pending = 0;
sg_wait_status(sgaddr, FRAME_SYNC);
sg_wait_status(sgaddr, FRAME_SYNC);
sgaddr->y_scroll_constant = SCROLL_ERASE;
sg_wait_status(sgaddr, FRAME_SYNC);
sg_wait_status(sgaddr, FRAME_SYNC);
sgaddr->y_offset_pending = 864;
sg_wait_status(sgaddr, FRAME_SYNC);
sg_wait_status(sgaddr, FRAME_SYNC);
sgaddr->y_scroll_constant = SCROLL_ERASE;
sg_wait_status(sgaddr, FRAME_SYNC);
sg_wait_status(sgaddr, FRAME_SYNC);
sgaddr->y_offset_pending = 1728;
sg_wait_status(sgaddr, FRAME_SYNC);
sg_wait_status(sgaddr, FRAME_SYNC);
sgaddr->y_scroll_constant = SCROLL_ERASE;
sg_wait_status(sgaddr, FRAME_SYNC);
sg_wait_status(sgaddr, FRAME_SYNC);
sgaddr->y_offset_pending = 0; /* back to normal */
sg_wait_status(sgaddr, FRAME_SYNC);
sg_wait_status(sgaddr, FRAME_SYNC);
sgaddr->x_limit = MAX_SCREEN_X;
sgaddr->y_limit = MAX_SCREEN_Y + FONT_HEIGHT;
}
/******************************************************************
** **
** Routine to put the console font in the off-screen memory **
** of the color VAXstar. **
** **
******************************************************************/
sg_ld_font()
{
register struct adder *sgaddr;
int i; /* scratch variables */
int j;
int k;
short packed;
sgaddr = (struct adder *) sgmap.adder;
/* setup VIPER operand control registers */
sg_write_id(sgaddr, MASK_1, 0xFFFF);
sg_write_id(sgaddr, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255);
sg_write_id(sgaddr, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);
sg_write_id(sgaddr, SRC1_OCR_B,
EXT_NONE | INT_NONE | ID | BAR_SHIFT_DELAY);
sg_write_id(sgaddr, SRC2_OCR_B,
EXT_NONE | INT_NONE | ID | BAR_SHIFT_DELAY);
sg_write_id(sgaddr, DST_OCR_B,
EXT_SOURCE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);
sgaddr->rasterop_mode = DST_WRITE_ENABLE |
DST_INDEX_ENABLE | NORMAL;
/* load destination data */
sg_wait_status(sgaddr, RASTEROP_COMPLETE);
sgaddr->destination_x = FONT_X;
sgaddr->destination_y = FONT_Y;
sgaddr->fast_dest_dx = FONT_WIDTH;
sgaddr->slow_dest_dy = CHAR_HEIGHT;
/* setup for processor to bitmap xfer */
sg_write_id(sgaddr, CS_UPDATE_MASK, 0x0001);
sgaddr->cmd = PBT | OCRB | 2 | DTE | 2;
/* iteratively do the processor to bitmap xfer */
for (i = 0; i < ROWS; ++i) {
/* PTOB a scan line */
for (j = 0, k = i; j < 48; ++j) {
/* PTOB one scan of a char cell */
packed = q_font[k];
k += ROWS;
packed |= ((short)q_font[k] << 8);
k += ROWS;
sg_wait_status(sgaddr, TX_READY);
sgaddr->id_data = packed;
}
}
}
/******************************************************************
** **
** Routine to scroll up the screen one character height **
** **
******************************************************************/
sg_scroll_up()
{
register struct adder *sgaddr;
/*
* setup VIPER operand control registers
*/
sg_wait_status(sgaddr, ADDRESS_COMPLETE);
sg_write_id(sgaddr, CS_UPDATE_MASK, 0x000F); /* select all planes */
sg_write_id(sgaddr, CS_SCROLL_MASK, 0x000F); /* select all planes */
sg_write_id(sgaddr, MASK_1, 0xFFFF);
sg_write_id(sgaddr, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 15);
sg_write_id(sgaddr, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);
sg_write_id(sgaddr, SRC1_OCR_B,
EXT_NONE | INT_SOURCE | ID | BAR_SHIFT_DELAY);
sg_write_id(sgaddr, DST_OCR_B,
EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);
/*
* load DESTINATION origin and vectors
*/
sgaddr->fast_dest_dy = 0;
sgaddr->slow_dest_dx = 0;
sgaddr->error_1 = 0;
sgaddr->error_2 = 0;
sgaddr->rasterop_mode = DST_WRITE_ENABLE | NORMAL;
sgaddr->destination_x = 0;
sgaddr->fast_dest_dx = 1024;
sgaddr->destination_y = 0;
sgaddr->slow_dest_dy = 864 - CHAR_HEIGHT;
/*
* load SOURCE origin and vectors
*/
sgaddr->source_1_x = 0;
sgaddr->source_1_dx = 1024;
sgaddr->source_1_y = CHAR_HEIGHT;
sgaddr->source_1_dy = 864 - CHAR_HEIGHT;
sg_write_id(sgaddr, LU_FUNCTION_R1, FULL_SRC_RESOLUTION | LF_SOURCE);
sgaddr->cmd = RASTEROP | OCRB | 0 | S1E | DTE;
/*
* do a rectangle clear of last screen line
*/
sg_write_id(sgaddr, MASK_1, 0xffff);
sg_write_id(sgaddr, SOURCE, 0xffff);
sg_write_id(sgaddr,DST_OCR_B,
(EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY));
sg_write_id(sgaddr, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 0);
sgaddr->error_1 = 0;
sgaddr->error_2 = 0;
sgaddr->slow_dest_dx = 0; /* set up the width of */
sgaddr->slow_dest_dy = CHAR_HEIGHT; /* rectangle */
sgaddr->rasterop_mode = (NORMAL | DST_WRITE_ENABLE) ;
sg_wait_status(sgaddr, RASTEROP_COMPLETE);
sgaddr->destination_x = 0;
sgaddr->destination_y = 864 - CHAR_HEIGHT;
sgaddr->fast_dest_dx = 1024; /* set up the height */
sgaddr->fast_dest_dy = 0; /* of rectangle */
sg_write_id(sgaddr, LU_FUNCTION_R2, (FULL_SRC_RESOLUTION | LF_SOURCE));
sgaddr->cmd = (RASTEROP | OCRB | LF_R2 | DTE ) ;
}
#endif
|
0001000002000337
00010000020007a4
*/
/* inherited classes
#ifndef _OZ0001000002000254P_H_
#define _OZ0001000002000254P_H_
#define OZClassPart0001000002fffffd_0_in_0001000002000254 1
#define OZClassPart0001000002fffffe_0_in_0001000002000254 1
#define OZClassPart0001000002000336_0_in_0001000002000254 -2
#define OZClassPart0001000002000337_0_in_0001000002000254 -2
#define OZClassPart00010000020007a3_0_in_0001000002000254 -1
#define OZClassPart00010000020007a4_0_in_0001000002000254 -1
#define OZClassPart0001000002000254_0_in_0001000002000254 0
#endif _OZ0001000002000254P_H_
|
void fit_mjj_Full_Dijet2017ScanbbCSV2b152()
{
//=========Macro generated from canvas: c/c
//========= (Thu Jul 26 13:11:40 2018) by ROOT version6.02/05
TCanvas *c = new TCanvas("c", "c",0,0,600,700);
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
c->SetHighLightColor(2);
c->Range(0,0,1,1);
c->SetFillColor(0);
c->SetBorderMode(0);
c->SetBorderSize(2);
c->SetTopMargin(0.04761905);
c->SetBottomMargin(0.05);
c->SetFrameBorderMode(0);
// ------------>Primitives in pad: c_1
TPad *c_1 = new TPad("c_1", "c_1",0.01,0.37,0.99,0.98);
c_1->Draw();
c_1->cd();
c_1->Range(2.91482,-2.30103,3.947382,1.465895);
c_1->SetFillColor(0);
c_1->SetBorderMode(0);
c_1->SetBorderSize(2);
c_1->SetLogx();
c_1->SetLogy();
c_1->SetLeftMargin(0.175);
c_1->SetRightMargin(0.05);
c_1->SetTopMargin(0.05);
c_1->SetBottomMargin(0);
c_1->SetFrameFillStyle(0);
c_1->SetFrameBorderMode(0);
c_1->SetFrameFillStyle(0);
c_1->SetFrameBorderMode(0);
Double_t xAxis1[45] = {1246, 1313, 1383, 1455, 1530, 1607, 1687, 1770, 1856, 1945, 2037, 2132, 2231, 2332, 2438, 2546, 2659, 2775, 2895, 3019, 3147, 3279, 3416, 3558, 3704, 3854, 4010, 4171, 4337, 4509, 4686, 4869, 5058, 5253, 5455, 5663, 5877, 6099, 6328, 6564, 6808, 7060, 7320, 7589, 7866};
TH1F *data_obs_density1 = new TH1F("data_obs_density1","pass_2CSV0.1522",44, xAxis1);
data_obs_density1->SetEntries(6.08674e+07);
data_obs_density1->SetLineColor(0);
data_obs_density1->SetLineWidth(0);
data_obs_density1->SetMarkerColor(0);
data_obs_density1->GetXaxis()->SetRange(1,44);
data_obs_density1->GetXaxis()->SetLabelFont(42);
data_obs_density1->GetXaxis()->SetLabelSize(0.035);
data_obs_density1->GetXaxis()->SetTitleSize(0.035);
data_obs_density1->GetXaxis()->SetTitleFont(42);
data_obs_density1->GetYaxis()->SetTitle("d#sigma/dm_{jj} [pb/TeV]");
data_obs_density1->GetYaxis()->SetLabelFont(42);
data_obs_density1->GetYaxis()->SetLabelSize(0.05);
data_obs_density1->GetYaxis()->SetTitleSize(0.07);
data_obs_density1->GetYaxis()->SetTitleFont(42);
data_obs_density1->GetZaxis()->SetLabelFont(42);
data_obs_density1->GetZaxis()->SetLabelSize(0.035);
data_obs_density1->GetZaxis()->SetTitleSize(0.035);
data_obs_density1->GetZaxis()->SetTitleFont(42);
data_obs_density1->Draw("axis");
TF1 *Dijet2017ScanbbCSV2b152_bkg_unbin1 = new TF1("*Dijet2017ScanbbCSV2b152_bkg_unbin",1246,7866,1);
//The original function : had originally been created by:
//TF1 *Dijet2017ScanbbCSV2b152_bkg_unbin = new TF1("Dijet2017ScanbbCSV2b152_bkg_unbin",,1246,7866,1);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetRange(1246,7866);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetName("Dijet2017ScanbbCSV2b152_bkg_unbin");
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetTitle("");
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(0,0.2880947);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(1,0.2595001);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(2,0.2268276);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(3,0.1934123);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(4,0.1615793);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(5,0.1327306);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(6,0.1075369);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(7,0.08615031);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(8,0.0683931);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(9,0.05390478);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(10,0.04224638);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(11,0.0329678);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(12,0.02564709);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(13,0.01991017);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(14,0.01543771);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(15,0.01196451);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(16,0.009274745);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(17,0.007195449);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(18,0.005589663);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(19,0.004349917);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(20,0.003392473);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(21,0.002652429);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(22,0.002079685);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(23,0.001635674);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(24,0.001290763);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(25,0.001022211);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(26,0.0008125726);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(27,0.0006484636);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(28,0.0005196093);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(29,0.0004181145);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(30,0.0003379042);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(31,0.0002742961);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(32,0.0002236741);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(33,0.0001832402);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(34,0.0001508235);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(35,0.0001247362);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(36,0.000103662);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(37,8.657174e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(38,7.265848e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(39,6.12875e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(40,5.195809e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(41,4.427402e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(42,3.792073e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(43,3.264772e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(44,2.825486e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(45,2.458171e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(46,2.149928e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(47,1.890351e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(48,1.671017e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(49,1.485087e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(50,1.326993e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(51,1.192185e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(52,1.076934e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(53,9.781793e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(54,8.933959e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(55,8.205e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(56,7.577669e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(57,7.037662e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(58,6.573108e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(59,6.174146e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(60,5.832589e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(61,5.541653e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(62,5.295736e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(63,5.090243e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(64,4.921447e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(65,4.786373e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(66,4.682717e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(67,4.608777e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(68,4.563411e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(69,4.546007e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(70,4.556468e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(71,4.595224e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(72,4.663243e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(73,4.76208e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(74,4.893928e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(75,5.061706e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(76,5.269167e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(77,5.521042e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(78,5.823229e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(79,6.183026e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(80,6.609445e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(81,7.113591e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(82,7.709173e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(83,8.413137e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(84,9.246497e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(85,1.02354e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(86,1.141254e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(87,1.281894e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(88,1.450637e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(89,1.654051e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(90,1.900513e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(91,2.200771e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(92,2.568702e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(93,3.022331e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(94,3.585229e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(95,4.288426e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(96,5.173054e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(97,6.294033e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(98,7.725227e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(99,9.566747e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(100,0.0001195533);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(101,1246);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetSavedPoint(102,7866);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetFillColor(19);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetFillStyle(0);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetLineColor(2);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetLineWidth(2);
Dijet2017ScanbbCSV2b152_bkg_unbin1->GetXaxis()->SetLabelFont(42);
Dijet2017ScanbbCSV2b152_bkg_unbin1->GetXaxis()->SetLabelSize(0.035);
Dijet2017ScanbbCSV2b152_bkg_unbin1->GetXaxis()->SetTitleSize(0.035);
Dijet2017ScanbbCSV2b152_bkg_unbin1->GetXaxis()->SetTitleFont(42);
Dijet2017ScanbbCSV2b152_bkg_unbin1->GetYaxis()->SetLabelFont(42);
Dijet2017ScanbbCSV2b152_bkg_unbin1->GetYaxis()->SetLabelSize(0.035);
Dijet2017ScanbbCSV2b152_bkg_unbin1->GetYaxis()->SetTitleSize(0.035);
Dijet2017ScanbbCSV2b152_bkg_unbin1->GetYaxis()->SetTitleFont(42);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetParameter(0,1.289076e-33);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetParError(0,0);
Dijet2017ScanbbCSV2b152_bkg_unbin1->SetParLimits(0,0,0);
Dijet2017ScanbbCSV2b152_bkg_unbin1->Draw("csame");
TLatex * tex = new TLatex(0.72,0.96,"41.8 fb^{-1} (13 TeV)");
tex->SetNDC();
tex->SetTextFont(42);
tex->SetTextSize(0.045);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0.22,0.89,"CMS");
tex->SetNDC();
tex->SetTextSize(0.065);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0.32,0.89,"Preliminary");
tex->SetNDC();
tex->SetTextFont(52);
tex->SetTextSize(0.045);
tex->SetLineWidth(2);
tex->Draw();
TLegend *leg = new TLegend(0.6,0.58,0.89,0.94,NULL,"brNDC");
leg->SetBorderSize(1);
leg->SetLineColor(0);
leg->SetLineStyle(1);
leg->SetLineWidth(0);
leg->SetFillColor(0);
leg->SetFillStyle(0);
TLegendEntry *entry=leg->AddEntry("Graph_from_data_obs_rebin","Data","pe");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(20);
entry->SetMarkerSize(0.9);
entry->SetTextFont(42);
entry=leg->AddEntry("Dijet2017ScanbbCSV2b152_bkg_unbin","Fit","l");
entry->SetLineColor(2);
entry->SetLineStyle(1);
entry->SetLineWidth(2);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(21);
entry->SetMarkerSize(1);
entry->SetTextFont(42);
leg->Draw();
TPaveText *pt = new TPaveText(0.2,0.03,0.5,0.23,"brNDC");
pt->SetBorderSize(0);
pt->SetFillColor(0);
pt->SetFillStyle(0);
pt->SetTextAlign(11);
pt->SetTextFont(42);
pt->SetTextSize(0.045);
AText = pt->AddText("#chi^{2} / ndf = 1284903.1 / 30 = 42830.1");
AText = pt->AddText("|#eta| < 2.5, |#Delta#eta| < 1.3");
pt->Draw();
TF1 *Dijet2017ScanbbCSV2b152_bkg_unbin2 = new TF1("*Dijet2017ScanbbCSV2b152_bkg_unbin",1246,7866,1);
//The original function : had originally been created by:
//TF1 *Dijet2017ScanbbCSV2b152_bkg_unbin = new TF1("Dijet2017ScanbbCSV2b152_bkg_unbin",,1246,7866,1);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetRange(1246,7866);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetName("Dijet2017ScanbbCSV2b152_bkg_unbin");
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetTitle("");
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(0,0.2880947);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(1,0.2595001);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(2,0.2268276);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(3,0.1934123);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(4,0.1615793);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(5,0.1327306);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(6,0.1075369);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(7,0.08615031);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(8,0.0683931);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(9,0.05390478);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(10,0.04224638);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(11,0.0329678);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(12,0.02564709);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(13,0.01991017);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(14,0.01543771);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(15,0.01196451);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(16,0.009274745);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(17,0.007195449);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(18,0.005589663);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(19,0.004349917);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(20,0.003392473);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(21,0.002652429);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(22,0.002079685);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(23,0.001635674);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(24,0.001290763);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(25,0.001022211);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(26,0.0008125726);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(27,0.0006484636);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(28,0.0005196093);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(29,0.0004181145);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(30,0.0003379042);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(31,0.0002742961);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(32,0.0002236741);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(33,0.0001832402);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(34,0.0001508235);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(35,0.0001247362);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(36,0.000103662);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(37,8.657174e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(38,7.265848e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(39,6.12875e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(40,5.195809e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(41,4.427402e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(42,3.792073e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(43,3.264772e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(44,2.825486e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(45,2.458171e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(46,2.149928e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(47,1.890351e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(48,1.671017e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(49,1.485087e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(50,1.326993e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(51,1.192185e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(52,1.076934e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(53,9.781793e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(54,8.933959e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(55,8.205e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(56,7.577669e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(57,7.037662e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(58,6.573108e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(59,6.174146e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(60,5.832589e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(61,5.541653e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(62,5.295736e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(63,5.090243e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(64,4.921447e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(65,4.786373e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(66,4.682717e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(67,4.608777e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(68,4.563411e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(69,4.546007e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(70,4.556468e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(71,4.595224e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(72,4.663243e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(73,4.76208e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(74,4.893928e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(75,5.061706e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(76,5.269167e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(77,5.521042e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(78,5.823229e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(79,6.183026e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(80,6.609445e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(81,7.113591e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(82,7.709173e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(83,8.413137e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(84,9.246497e-06);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(85,1.02354e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(86,1.141254e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(87,1.281894e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(88,1.450637e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(89,1.654051e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(90,1.900513e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(91,2.200771e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(92,2.568702e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(93,3.022331e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(94,3.585229e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(95,4.288426e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(96,5.173054e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(97,6.294033e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(98,7.725227e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(99,9.566747e-05);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(100,0.0001195533);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(101,1246);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetSavedPoint(102,7866);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetFillColor(19);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetFillStyle(0);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetLineColor(2);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetLineWidth(2);
Dijet2017ScanbbCSV2b152_bkg_unbin2->GetXaxis()->SetLabelFont(42);
Dijet2017ScanbbCSV2b152_bkg_unbin2->GetXaxis()->SetLabelSize(0.035);
Dijet2017ScanbbCSV2b152_bkg_unbin2->GetXaxis()->SetTitleSize(0.035);
Dijet2017ScanbbCSV2b152_bkg_unbin2->GetXaxis()->SetTitleFont(42);
Dijet2017ScanbbCSV2b152_bkg_unbin2->GetYaxis()->SetLabelFont(42);
Dijet2017ScanbbCSV2b152_bkg_unbin2->GetYaxis()->SetLabelSize(0.035);
Dijet2017ScanbbCSV2b152_bkg_unbin2->GetYaxis()->SetTitleSize(0.035);
Dijet2017ScanbbCSV2b152_bkg_unbin2->GetYaxis()->SetTitleFont(42);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetParameter(0,1.289076e-33);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetParError(0,0);
Dijet2017ScanbbCSV2b152_bkg_unbin2->SetParLimits(0,0,0);
Dijet2017ScanbbCSV2b152_bkg_unbin2->Draw("csame");
Double_t g_data_clone_fx3001[44] = {
1279.5,
1348,
1419,
1492.5,
1568.5,
1647,
1728.5,
1813,
1900.5,
1991,
2084.5,
2181.5,
2281.5,
2385,
2492,
2602.5,
2717,
2835,
2957,
3083,
3213,
3347.5,
3487,
3631,
3779,
3932,
4090.5,
4254,
4423,
4597.5,
4777.5,
4963.5,
5155.5,
5354,
5559,
5770,
5988,
6213.5,
6446,
6686,
6934,
7190,
7454.5,
7727.5};
Double_t g_data_clone_fy3001[44] = {
0,
0.680445,
0,
0.337133,
0,
0.1750553,
0,
0.09292673,
0.05294957,
0,
0.02991765,
0,
0.01730731,
0.01043784,
0,
0.006326163,
0.004023057,
0.002569179,
0.001670397,
0,
0.001062418,
0.0007040827,
0.0004707191,
0.000329357,
0.0002333333,
0.0001610232,
0.0001084728,
7.090563e-05,
5.035051e-05,
3.676371e-05,
4.680106e-05,
1.417686e-05,
8.342535e-06,
6.632242e-06,
8.626242e-06,
2.906587e-06,
3.663951e-06,
1.044692e-06,
1.520558e-06,
1.960938e-07,
5.696058e-07,
1.840265e-07,
0,
0};
Double_t g_data_clone_felx3001[44] = {
33.5,
35,
36,
37.5,
38.5,
40,
41.5,
43,
44.5,
46,
47.5,
49.5,
50.5,
53,
54,
56.5,
58,
60,
62,
64,
66,
68.5,
71,
73,
75,
78,
80.5,
83,
86,
88.5,
91.5,
94.5,
97.5,
101,
104,
107,
111,
114.5,
118,
122,
126,
130,
134.5,
138.5};
Double_t g_data_clone_fely3001[44] = {
0,
0.0004822461,
0,
0.0003279376,
0,
0.0002288041,
0,
0.0001607838,
0.0001193046,
0,
8.680058e-05,
0,
6.402865e-05,
4.853691e-05,
0,
3.659736e-05,
2.880492e-05,
2.263196e-05,
1.795196e-05,
0,
1.387617e-05,
1.108804e-05,
8.90496e-06,
7.345851e-06,
6.099783e-06,
4.968599e-06,
4.013924e-06,
3.195655e-06,
2.645198e-06,
2.227804e-06,
2.47241e-06,
1.337612e-06,
1.009207e-06,
8.836335e-07,
9.938669e-07,
5.663496e-07,
6.252683e-07,
3.247684e-07,
3.881933e-07,
1.266599e-07,
2.259407e-07,
1.188654e-07,
0,
0};
Double_t g_data_clone_fehx3001[44] = {
33.5,
35,
36,
37.5,
38.5,
40,
41.5,
43,
44.5,
46,
47.5,
49.5,
50.5,
53,
54,
56.5,
58,
60,
62,
64,
66,
68.5,
71,
73,
75,
78,
80.5,
83,
86,
88.5,
91.5,
94.5,
97.5,
101,
104,
107,
111,
114.5,
118,
122,
126,
130,
134.5,
138.5};
Double_t g_data_clone_fehy3001[44] = {
6.573787e-07,
0.000482588,
6.117274e-07,
0.0003282568,
5.720048e-07,
0.0002291034,
5.306551e-07,
0.0001610622,
0.0001195737,
4.787432e-07,
8.705278e-05,
4.448926e-07,
6.426596e-05,
4.876314e-05,
4.078183e-07,
3.680969e-05,
2.90119e-05,
2.28322e-05,
1.814593e-05,
3.440967e-07,
1.40586e-05,
1.126404e-05,
9.075034e-06,
7.511544e-06,
6.261363e-06,
5.124327e-06,
4.165274e-06,
3.343029e-06,
2.787952e-06,
2.367073e-06,
2.606602e-06,
1.470187e-06,
1.139352e-06,
1.010003e-06,
1.115543e-06,
6.891351e-07,
7.422996e-07,
4.457737e-07,
5.026801e-07,
2.586389e-07,
3.402173e-07,
2.427227e-07,
1.637337e-07,
1.59005e-07};
TGraphAsymmErrors *grae = new TGraphAsymmErrors(44,g_data_clone_fx3001,g_data_clone_fy3001,g_data_clone_felx3001,g_data_clone_fehx3001,g_data_clone_fely3001,g_data_clone_fehy3001);
grae->SetName("g_data_clone");
grae->SetTitle("pass_2CSV0.1522");
grae->SetMarkerStyle(20);
grae->SetMarkerSize(0);
TH1F *Graph_g_data_clone3001 = new TH1F("Graph_g_data_clone3001","pass_2CSV0.1522",100,584,8528);
Graph_g_data_clone3001->SetMinimum(0.0007490203);
Graph_g_data_clone3001->SetMaximum(0.7490203);
Graph_g_data_clone3001->SetDirectory(0);
Graph_g_data_clone3001->SetStats(0);
Int_t ci; // for color index setting
TColor *color; // for color definition with alpha
ci = TColor::GetColor("#000099");
Graph_g_data_clone3001->SetLineColor(ci);
Graph_g_data_clone3001->GetXaxis()->SetLabelFont(42);
Graph_g_data_clone3001->GetXaxis()->SetLabelSize(0.035);
Graph_g_data_clone3001->GetXaxis()->SetTitleSize(0.035);
Graph_g_data_clone3001->GetXaxis()->SetTitleFont(42);
Graph_g_data_clone3001->GetYaxis()->SetLabelFont(42);
Graph_g_data_clone3001->GetYaxis()->SetLabelSize(0.035);
Graph_g_data_clone3001->GetYaxis()->SetTitleSize(0.035);
Graph_g_data_clone3001->GetYaxis()->SetTitleFont(42);
Graph_g_data_clone3001->GetZaxis()->SetLabelFont(42);
Graph_g_data_clone3001->GetZaxis()->SetLabelSize(0.035);
Graph_g_data_clone3001->GetZaxis()->SetTitleSize(0.035);
Graph_g_data_clone3001->GetZaxis()->SetTitleFont(42);
grae->SetHistogram(Graph_g_data_clone3001);
grae->Draw("zp");
Double_t Graph_from_data_obs_rebin_fx3002[44] = {
1279.5,
1348,
1419,
1492.5,
1568.5,
1647,
1728.5,
1813,
1900.5,
1991,
2084.5,
2181.5,
2281.5,
2385,
2492,
2602.5,
2717,
2835,
2957,
3083,
3213,
3347.5,
3487,
3631,
3779,
3932,
4090.5,
4254,
4423,
4597.5,
4777.5,
4963.5,
5155.5,
5354,
5559,
5770,
5988,
6213.5,
6446,
6686,
6934,
7190,
7454.5,
7727.5};
Double_t Graph_from_data_obs_rebin_fy3002[44] = {
99999,
0.680445,
99999,
0.337133,
99999,
0.1750553,
99999,
0.09292673,
0.05294957,
99999,
0.02991765,
99999,
0.01730731,
0.01043784,
99999,
0.006326163,
0.004023057,
0.002569179,
0.001670397,
99999,
0.001062418,
0.0007040827,
0.0004707191,
0.000329357,
0.0002333333,
0.0001610232,
0.0001084728,
7.090563e-05,
5.035051e-05,
3.676371e-05,
4.680106e-05,
1.417686e-05,
8.342535e-06,
6.632242e-06,
8.626242e-06,
2.906587e-06,
3.663951e-06,
1.044692e-06,
1.520558e-06,
1.960938e-07,
5.696058e-07,
1.840265e-07,
99999,
99999};
Double_t Graph_from_data_obs_rebin_felx3002[44] = {
33.5,
35,
36,
37.5,
38.5,
40,
41.5,
43,
44.5,
46,
47.5,
49.5,
50.5,
53,
54,
56.5,
58,
60,
62,
64,
66,
68.5,
71,
73,
75,
78,
80.5,
83,
86,
88.5,
91.5,
94.5,
97.5,
101,
104,
107,
111,
114.5,
118,
122,
126,
130,
134.5,
138.5};
Double_t Graph_from_data_obs_rebin_fely3002[44] = {
0,
0.0004822461,
0,
0.0003279376,
0,
0.0002288041,
0,
0.0001607838,
0.0001193046,
0,
8.680058e-05,
0,
6.402865e-05,
4.853691e-05,
0,
3.659736e-05,
2.880492e-05,
2.263196e-05,
1.795196e-05,
0,
1.387617e-05,
1.108804e-05,
8.90496e-06,
7.345851e-06,
6.099783e-06,
4.968599e-06,
4.013924e-06,
3.195655e-06,
2.645198e-06,
2.227804e-06,
2.47241e-06,
1.337612e-06,
1.009207e-06,
8.836335e-07,
9.938669e-07,
5.663496e-07,
6.252683e-07,
3.247684e-07,
3.881933e-07,
1.266599e-07,
2.259407e-07,
1.188654e-07,
0,
0};
Double_t Graph_from_data_obs_rebin_fehx3002[44] = {
33.5,
35,
36,
37.5,
38.5,
40,
41.5,
43,
44.5,
46,
47.5,
49.5,
50.5,
53,
54,
56.5,
58,
60,
62,
64,
66,
68.5,
71,
73,
75,
78,
80.5,
83,
86,
88.5,
91.5,
94.5,
97.5,
101,
104,
107,
111,
114.5,
118,
122,
126,
130,
134.5,
138.5};
Double_t Graph_from_data_obs_rebin_fehy3002[44] = {
6.573787e-07,
0.000482588,
6.117274e-07,
0.0003282568,
5.720048e-07,
0.0002291034,
5.306551e-07,
0.0001610622,
0.0001195737,
4.787432e-07,
8.705278e-05,
4.448926e-07,
6.426596e-05,
4.876314e-05,
4.078183e-07,
3.680969e-05,
2.90119e-05,
2.28322e-05,
1.814593e-05,
3.440967e-07,
1.40586e-05,
1.126404e-05,
9.075034e-06,
7.511544e-06,
6.261363e-06,
5.124327e-06,
4.165274e-06,
3.343029e-06,
2.787952e-06,
2.367073e-06,
2.606602e-06,
1.470187e-06,
1.139352e-06,
1.010003e-06,
1.115543e-06,
6.891351e-07,
7.422996e-07,
4.457737e-07,
5.026801e-07,
2.586389e-07,
3.402173e-07,
2.427227e-07,
1.637337e-07,
1.59005e-07};
grae = new TGraphAsymmErrors(44,Graph_from_data_obs_rebin_fx3002,Graph_from_data_obs_rebin_fy3002,Graph_from_data_obs_rebin_felx3002,Graph_from_data_obs_rebin_fehx3002,Graph_from_data_obs_rebin_fely3002,Graph_from_data_obs_rebin_fehy3002);
grae->SetName("Graph_from_data_obs_rebin");
grae->SetTitle("pass_2CSV0.1522");
grae->SetMarkerStyle(20);
grae->SetMarkerSize(0.9);
TH1F *Graph_Graph_from_data_obs_rebin3002 = new TH1F("Graph_Graph_from_data_obs_rebin3002","pass_2CSV0.1522",100,584,8528);
Graph_Graph_from_data_obs_rebin3002->SetMinimum(5.864495e-08);
Graph_Graph_from_data_obs_rebin3002->SetMaximum(109998.9);
Graph_Graph_from_data_obs_rebin3002->SetDirectory(0);
Graph_Graph_from_data_obs_rebin3002->SetStats(0);
ci = TColor::GetColor("#000099");
Graph_Graph_from_data_obs_rebin3002->SetLineColor(ci);
Graph_Graph_from_data_obs_rebin3002->GetXaxis()->SetLabelFont(42);
Graph_Graph_from_data_obs_rebin3002->GetXaxis()->SetLabelSize(0.035);
Graph_Graph_from_data_obs_rebin3002->GetXaxis()->SetTitleSize(0.035);
Graph_Graph_from_data_obs_rebin3002->GetXaxis()->SetTitleFont(42);
Graph_Graph_from_data_obs_rebin3002->GetYaxis()->SetLabelFont(42);
Graph_Graph_from_data_obs_rebin3002->GetYaxis()->SetLabelSize(0.035);
Graph_Graph_from_data_obs_rebin3002->GetYaxis()->SetTitleSize(0.035);
Graph_Graph_from_data_obs_rebin3002->GetYaxis()->SetTitleFont(42);
Graph_Graph_from_data_obs_rebin3002->GetZaxis()->SetLabelFont(42);
Graph_Graph_from_data_obs_rebin3002->GetZaxis()->SetLabelSize(0.035);
Graph_Graph_from_data_obs_rebin3002->GetZaxis()->SetTitleSize(0.035);
Graph_Graph_from_data_obs_rebin3002->GetZaxis()->SetTitleFont(42);
grae->SetHistogram(Graph_Graph_from_data_obs_rebin3002);
grae->Draw("zp");
c_1->Modified();
c->cd();
// ------------>Primitives in pad: c_2
TPad *c_2 = new TPad("c_2", "c_2",0.01,0.02,0.99,0.37);
c_2->Draw();
c_2->cd();
c_2->Range(2.91482,-7.269231,3.947382,3.5);
c_2->SetFillColor(0);
c_2->SetBorderMode(0);
c_2->SetBorderSize(2);
c_2->SetLogx();
c_2->SetGridx();
c_2->SetGridy();
c_2->SetLeftMargin(0.175);
c_2->SetRightMargin(0.05);
c_2->SetTopMargin(0);
c_2->SetBottomMargin(0.35);
c_2->SetFrameBorderMode(0);
c_2->SetFrameBorderMode(0);
Double_t xAxis2[45] = {1246, 1313, 1383, 1455, 1530, 1607, 1687, 1770, 1856, 1945, 2037, 2132, 2231, 2332, 2438, 2546, 2659, 2775, 2895, 3019, 3147, 3279, 3416, 3558, 3704, 3854, 4010, 4171, 4337, 4509, 4686, 4869, 5058, 5253, 5455, 5663, 5877, 6099, 6328, 6564, 6808, 7060, 7320, 7589, 7866};
TH1D *h_fit_residual_vs_mass2 = new TH1D("h_fit_residual_vs_mass2","h_fit_residual_vs_mass",44, xAxis2);
h_fit_residual_vs_mass2->SetBinContent(1,-416993.6);
h_fit_residual_vs_mass2->SetBinContent(2,909.1629);
h_fit_residual_vs_mass2->SetBinContent(3,-337233.2);
h_fit_residual_vs_mass2->SetBinContent(4,508.8219);
h_fit_residual_vs_mass2->SetBinContent(5,-238535.4);
h_fit_residual_vs_mass2->SetBinContent(6,299.8891);
h_fit_residual_vs_mass2->SetBinContent(7,-152453.8);
h_fit_residual_vs_mass2->SetBinContent(8,204.5009);
h_fit_residual_vs_mass2->SetBinContent(9,78.18042);
h_fit_residual_vs_mass2->SetBinContent(10,-64939.99);
h_fit_residual_vs_mass2->SetBinContent(11,93.67092);
h_fit_residual_vs_mass2->SetBinContent(12,-33759.42);
h_fit_residual_vs_mass2->SetBinContent(13,110.6278);
h_fit_residual_vs_mass2->SetBinContent(14,73.32928);
h_fit_residual_vs_mass2->SetBinContent(15,-11232.39);
h_fit_residual_vs_mass2->SetBinContent(16,90.10539);
h_fit_residual_vs_mass2->SetBinContent(17,70.67211);
h_fit_residual_vs_mass2->SetBinContent(18,56.06746);
h_fit_residual_vs_mass2->SetBinContent(19,45.78217);
h_fit_residual_vs_mass2->SetBinContent(20,-1608.866);
h_fit_residual_vs_mass2->SetBinContent(21,50.47706);
h_fit_residual_vs_mass2->SetBinContent(22,42.08344);
h_fit_residual_vs_mass2->SetBinContent(23,35.29241);
h_fit_residual_vs_mass2->SetBinContent(24,30.68492);
h_fit_residual_vs_mass2->SetBinContent(25,26.78369);
h_fit_residual_vs_mass2->SetBinContent(26,22.80695);
h_fit_residual_vs_mass2->SetBinContent(27,18.79807);
h_fit_residual_vs_mass2->SetBinContent(28,14.89467);
h_fit_residual_vs_mass2->SetBinContent(29,12.67502);
h_fit_residual_vs_mass2->SetBinContent(30,10.90824);
h_fit_residual_vs_mass2->SetBinContent(31,15.08049);
h_fit_residual_vs_mass2->SetBinContent(32,4.97874);
h_fit_residual_vs_mass2->SetBinContent(33,2.148526);
h_fit_residual_vs_mass2->SetBinContent(34,1.508631);
h_fit_residual_vs_mass2->SetBinContent(35,3.868406);
h_fit_residual_vs_mass2->SetBinContent(36,-2.408769);
h_fit_residual_vs_mass2->SetBinContent(37,-1.326804);
h_fit_residual_vs_mass2->SetBinContent(38,-9.071865);
h_fit_residual_vs_mass2->SetBinContent(39,-9.00359);
h_fit_residual_vs_mass2->SetBinContent(40,-29.73846);
h_fit_residual_vs_mass2->SetBinContent(41,-31.97854);
h_fit_residual_vs_mass2->SetBinContent(42,-76.59273);
h_fit_residual_vs_mass2->SetBinContent(43,-216.5192);
h_fit_residual_vs_mass2->SetBinContent(44,-495.1461);
h_fit_residual_vs_mass2->SetBinError(1,1);
h_fit_residual_vs_mass2->SetBinError(2,1);
h_fit_residual_vs_mass2->SetBinError(3,1);
h_fit_residual_vs_mass2->SetBinError(4,1);
h_fit_residual_vs_mass2->SetBinError(5,1);
h_fit_residual_vs_mass2->SetBinError(6,1);
h_fit_residual_vs_mass2->SetBinError(7,1);
h_fit_residual_vs_mass2->SetBinError(8,1);
h_fit_residual_vs_mass2->SetBinError(9,1);
h_fit_residual_vs_mass2->SetBinError(10,1);
h_fit_residual_vs_mass2->SetBinError(11,1);
h_fit_residual_vs_mass2->SetBinError(12,1);
h_fit_residual_vs_mass2->SetBinError(13,1);
h_fit_residual_vs_mass2->SetBinError(14,1);
h_fit_residual_vs_mass2->SetBinError(15,1);
h_fit_residual_vs_mass2->SetBinError(16,1);
h_fit_residual_vs_mass2->SetBinError(17,1);
h_fit_residual_vs_mass2->SetBinError(18,1);
h_fit_residual_vs_mass2->SetBinError(19,1);
h_fit_residual_vs_mass2->SetBinError(20,1);
h_fit_residual_vs_mass2->SetBinError(21,1);
h_fit_residual_vs_mass2->SetBinError(22,1);
h_fit_residual_vs_mass2->SetBinError(23,1);
h_fit_residual_vs_mass2->SetBinError(24,1);
h_fit_residual_vs_mass2->SetBinError(25,1);
h_fit_residual_vs_mass2->SetBinError(26,1);
h_fit_residual_vs_mass2->SetBinError(27,1);
h_fit_residual_vs_mass2->SetBinError(28,1);
h_fit_residual_vs_mass2->SetBinError(29,1);
h_fit_residual_vs_mass2->SetBinError(30,1);
h_fit_residual_vs_mass2->SetBinError(31,1);
h_fit_residual_vs_mass2->SetBinError(32,1);
h_fit_residual_vs_mass2->SetBinError(33,1);
h_fit_residual_vs_mass2->SetBinError(34,1);
h_fit_residual_vs_mass2->SetBinError(35,1);
h_fit_residual_vs_mass2->SetBinError(36,1);
h_fit_residual_vs_mass2->SetBinError(37,1);
h_fit_residual_vs_mass2->SetBinError(38,1);
h_fit_residual_vs_mass2->SetBinError(39,1);
h_fit_residual_vs_mass2->SetBinError(40,1);
h_fit_residual_vs_mass2->SetBinError(41,1);
h_fit_residual_vs_mass2->SetBinError(42,1);
h_fit_residual_vs_mass2->SetBinError(43,1);
h_fit_residual_vs_mass2->SetBinError(44,1);
h_fit_residual_vs_mass2->SetMinimum(-3.5);
h_fit_residual_vs_mass2->SetMaximum(3.5);
h_fit_residual_vs_mass2->SetEntries(44);
h_fit_residual_vs_mass2->SetStats(0);
ci = TColor::GetColor("#ff0000");
h_fit_residual_vs_mass2->SetFillColor(ci);
h_fit_residual_vs_mass2->GetXaxis()->SetTitle("Dijet mass [TeV]");
h_fit_residual_vs_mass2->GetXaxis()->SetRange(1,44);
h_fit_residual_vs_mass2->GetXaxis()->SetMoreLogLabels();
h_fit_residual_vs_mass2->GetXaxis()->SetNoExponent();
h_fit_residual_vs_mass2->GetXaxis()->SetNdivisions(999);
h_fit_residual_vs_mass2->GetXaxis()->SetLabelFont(42);
h_fit_residual_vs_mass2->GetXaxis()->SetLabelOffset(1000);
h_fit_residual_vs_mass2->GetXaxis()->SetLabelSize(0.1);
h_fit_residual_vs_mass2->GetXaxis()->SetTitleSize(0.12);
h_fit_residual_vs_mass2->GetXaxis()->SetTitleFont(42);
h_fit_residual_vs_mass2->GetYaxis()->SetTitle("#frac{(Data-Fit)}{Uncertainty}");
h_fit_residual_vs_mass2->GetYaxis()->SetNdivisions(210);
h_fit_residual_vs_mass2->GetYaxis()->SetLabelFont(42);
h_fit_residual_vs_mass2->GetYaxis()->SetLabelSize(0.1);
h_fit_residual_vs_mass2->GetYaxis()->SetTitleSize(0.12);
h_fit_residual_vs_mass2->GetYaxis()->SetTitleOffset(0.6);
h_fit_residual_vs_mass2->GetYaxis()->SetTitleFont(42);
h_fit_residual_vs_mass2->GetZaxis()->SetLabelFont(42);
h_fit_residual_vs_mass2->GetZaxis()->SetLabelSize(0.035);
h_fit_residual_vs_mass2->GetZaxis()->SetTitleSize(0.035);
h_fit_residual_vs_mass2->GetZaxis()->SetTitleFont(42);
h_fit_residual_vs_mass2->Draw("hist");
tex = new TLatex(2000,-4,"2");
tex->SetTextAlign(22);
tex->SetTextFont(42);
tex->SetTextSize(0.1);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(3000,-4,"3");
tex->SetTextAlign(22);
tex->SetTextFont(42);
tex->SetTextSize(0.1);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(4000,-4,"4");
tex->SetTextAlign(22);
tex->SetTextFont(42);
tex->SetTextSize(0.1);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(5000,-4,"5");
tex->SetTextAlign(22);
tex->SetTextFont(42);
tex->SetTextSize(0.1);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(6000,-4,"6");
tex->SetTextAlign(22);
tex->SetTextFont(42);
tex->SetTextSize(0.1);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(7000,-4,"7");
tex->SetTextAlign(22);
tex->SetTextFont(42);
tex->SetTextSize(0.1);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(8000,-4,"8");
tex->SetTextAlign(22);
tex->SetTextFont(42);
tex->SetTextSize(0.1);
tex->SetLineWidth(2);
tex->Draw();
TGaxis *gaxis = new TGaxis(1246,-3.5,7866,-3.5,1246,7866,509,"BS");
gaxis->SetLabelOffset(1000);
gaxis->SetLabelSize(0.04);
gaxis->SetTickSize(0.03);
gaxis->SetGridLength(0);
gaxis->SetTitleOffset(1);
gaxis->SetTitleSize(0.04);
gaxis->SetTitleColor(1);
gaxis->SetTitleFont(62);
gaxis->SetMoreLogLabels();
gaxis->Draw();
c_2->Modified();
c->cd();
c->Modified();
c->cd();
c->SetSelected(c);
}
|
#include "libwchar.h"
static const char _u8cmaxlen = 4;
static const char _u8bit = '\x80';
static const char _u8bits[] = {'\x0', '\xc0', '\xe0', '\xf0', '\xf8', '\xfc'};
static const wchar_t _wcsrange[] = { L'\x0', L'\x80', L'\x800', L'\xfffe' };
static const char _u8vallen = 6;
size_t u8stowcs(wchar_t *wcs, const char *u8s) {
size_t len = 0;
wchar_t *p_wcs = wcs;
size_t rp_u8s = 0;
char u8;
while ((u8 = *(u8s + rp_u8s++)) != '\0') {
wchar_t wc = L'\xfffd';
char b;
for (b = _u8cmaxlen - 1; b >= 0; b--)
if ((_u8bits[(unsigned char)b] & u8) == _u8bits[(unsigned char)b])
break;
if (b >= 0) {
len++;
if (wcs) {
wc = (u8 ^ _u8bits[(unsigned char)b]) << b * _u8vallen;
while (b-- > 0) {
u8 = *(u8s + rp_u8s++);
if ((_u8bit & u8) == _u8bit) {
wc += (u8 ^ _u8bit) << b * _u8vallen;
} else {
wc = L'\xfffd';
break;
}
}
*p_wcs++ = wc;
}
}
}
if (wcs)
*p_wcs = L'\0';
return len;
}
size_t wcstou8s(char *u8s, const wchar_t *wcs) {
size_t len = 0;
char *p_u8s = u8s;
size_t rp_wcs = 0;
wchar_t wc;
while ((wc = *(wcs + rp_wcs++)) != L'\0') {
char b;
for (b = _u8cmaxlen - 1; b; b--)
if (_wcsrange[(unsigned char)b] < wc) { break; }
len += b + 1;
if (u8s) {
*p_u8s = _u8bits[(unsigned char)b];
p_u8s += b;
char c = b;
while (c-- > 0) {
*p_u8s = _u8bit + (wc & L'\x3f');
wc >>= 6;
p_u8s--;
}
*p_u8s++ |= wc;
p_u8s += b;
}
}
if (u8s)
*p_u8s = '\0';
return len;
}
int u8sverify(const char *u8s)
{
unsigned char prev, cur;
prev = *u8s;
u8s++;
cur = *u8s;
while (cur != '\0') {
// 0xd800 <= byte <= 0xdfff
if ((0xd8 <= prev) && (prev <= 0xdf)) {
return 0;
}
// 0xfffe <= byte <= 0xffff
if ((prev == 0xff) &&((0xfe <= cur) && (cur < 0xff))) {
return 0;
}
prev = cur;
u8s++;
cur = *u8s;
}
return 1;
}
|
/*******************************************************************************
* Application: Demo code for IIC using in HHD32F0xx
* Edition: Version:1.0
* Company:
* Time: October 2015
*******************************************************************************/
#include "hhd32f1xx.h"
#include "hhd_sys.h"
#include "hhd_iic.h"
void IIC_IOCONFIG(void);
void delaynstep(int i)
{
while(i--);
}
/*****************************************************************************
* Function name: Main Function
*
* Descriptions: IIC drive HT1621 LCD driver chip.
*
* parameters: None
* Returned value: None
*
*****************************************************************************/
int main(void)
{
//int i;
/* --------- System initialization -------------------*/
SystemInit();
/* --------- Config I2C1 AFIO assignment -------------*/
IIC_IOCONFIG();
/* --------- IIC initiallization ---------------------*/
IIC_Init(I2C1,1,50,0x70);
/* --------- Send Data to I2C slave ------------------*/
IIC_WriteByte(I2C1,0x70,0x80,3);
while(1);
}
void IIC_IOCONFIG(void)
{
#if 1 //IIC1, SCL-> PB6, SDA-> PB7
IIC1_SCL_PB6;
IIC1_SDA_PB7;
#endif
#if 0 //IIC1, SCL-> PB8, SDA-> PB8
IIC1_SCL_PB8;
IIC1_SDA_PB9;
#endif
#if 0 //IIC2, SCL-> PB10, SDA-> PB11
IIC2_SCL_PB10;
IIC2_SDA_PB11;
#endif
}
void I2C1_IRQHandler()
{
IIC_IRQHandler(I2C1);
}
|
/* Copyright (C) 2017-2018 Intel Corporation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted for any purpose (including commercial purposes)
* provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions, and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions, and the following disclaimer in the
* documentation and/or materials provided with the distribution.
*
* 3. In addition, redistributions of modified forms of the source or binary
* code must carry prominent notices stating that the original code was
* changed and the date of the change.
*
* 4. All publications or advertising materials mentioning features or use of
* this software are asked, but not required, to acknowledge that it was
* developed by Intel Corporation and credit the contributors.
*
* 5. Neither the name of Intel Corporation, nor the name of any Contributor
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __IOF_CTRL_UTIL_H__
#define __IOF_CTRL_UTIL_H__
#include <iof_defines.h>
#if defined(__cplusplus)
extern "C" {
#endif
/* Maximum length of a CTRL string with NULL character */
#define IOF_CTRL_MAX_LEN 4096
#define IOF_CTRL_MAX_CONSTANT_LEN 128
enum iof_ctrl_error {
IOF_CTRL_SUCCESS,
IOF_CTRL_NOT_FOUND,
IOF_CTRL_INVALID_ARG,
IOF_CTRL_NOT_INITIALIZED,
IOF_CTRL_OPEN_FAILED,
IOF_CTRL_IO_FAILED,
IOF_CTRL_BAD_FILE,
};
/* Initialize the cnss ctrl fs utility library. Returns the
* CNSS_PREFIX if found and the CNSS identifier
*/
int IOF_PUBLIC iof_ctrl_util_init(const char **prefix, int *id);
/* Finalize the cnss ctrl fs utility library. */
int IOF_PUBLIC iof_ctrl_util_finalize(void);
/* Copies contents of ctrl file to str if NULL terminated
* string will fit in len characters.
* \param str[out] buffer to write
* \param len[in] size in bytes of str
* \param path[in] path to control (relative to ctrl root)
* \retval 0 if successful
* \retval required_len if not enough space (str unchanged)
* \retval -errcode on any other error
*/
int IOF_PUBLIC iof_ctrl_read_str(char *str, int len, const char *path);
/* Gets a value from ctrl fs as a 64-bit integer
* \param val[out] value to write
* \param path[in] path to control (relative to ctrl root)
* \retval 0 on success
* \retval -errcode on error
*/
int IOF_PUBLIC iof_ctrl_read_int64(int64_t *val, const char *path);
/* Gets a value from ctrl fs as a 32-bit integer
* \param val[out] value to write
* \param path[in] path to control (relative to ctrl root)
* \retval 0 on success
* \retval -errcode on error
*/
int IOF_PUBLIC iof_ctrl_read_int32(int32_t *val, const char *path);
/* Gets a value from ctrl fs as a 64-bit unsigned integer
* \param val[out] value to write
* \param path[in] path to control (relative to ctrl root)
* \retval 0 on success
* \retval -errcode on error
*/
int IOF_PUBLIC iof_ctrl_read_uint64(uint64_t *val, const char *path);
/* Gets a value from ctrl fs as a 32-bit unsigned integer
* \param val[out] value to write
* \param path[in] path to control (relative to ctrl root)
* \retval 0 on success
* \retval -errcode on error
*/
int IOF_PUBLIC iof_ctrl_read_uint32(uint32_t *val, const char *path);
/* Trigger a control event
* \param path[in] path to control (relative to ctrl root)
* \retval 0 on success
* \retval -errcode on error
*/
int IOF_PUBLIC iof_ctrl_trigger(const char *path);
/* Gets a tracker id from ctrl fs
* \param val[out] value to write
* \param path[in] path to control (relative to ctrl root)
* \retval 0 on success
* \retval -errcode on error
*/
int IOF_PUBLIC iof_ctrl_get_tracker_id(int *value, const char *path);
/* Write a string to a ctrl file
* \param str[in] value to write
* \param path[in] path to control (relative to ctrl root)
* \retval 0 if successful
* \retval required_len if not enough space (str unchanged)
* \retval -errcode on any other error
*/
#define iof_ctrl_write_str(str, path) \
iof_ctrl_write_strf(path, "%s", str)
/* Write format string to ctrl variable
* \param path[in] path to control (relative to ctrl root)
* \param format[in] format string
* \retval 0 if successful
* \retval required_len if not enough space (str unchanged)
* \retval -errcode on any other error
*/
int IOF_PUBLIC iof_ctrl_write_strf(const char *path, const char *format, ...)
__attribute__ ((__format__(__printf__, 2, 3)));
/* Write a 64 bit int to a ctrl file
* \param val[in] value to write
* \param path[in] path to control (relative to ctrl root)
* \retval 0 if successful
* \retval -errcode on any other error
*/
#define iof_ctrl_write_int64(val, path) \
iof_ctrl_write_strf(path, "%" PRIi64, ((int64_t)(val)))
/* Write a 64 bit uint to a ctrl file
* \param val[in] value to write
* \param path[in] path to control (relative to ctrl root)
* \retval 0 if successful
* \retval -errcode on any other error
*/
#define iof_ctrl_write_uint64(val, path) \
iof_ctrl_write_strf(path, "%" PRIu64, ((uint64_t)(val)))
#if defined(__cplusplus)
extern "C" }
#endif
#endif /* __IOF_CTRL_UTIL_H__ */
|
#include "sp_fetchmail.h"
#include <string.h>
#include <strings.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#if 0
/* https://technet.microsoft.com/en-us/library/bb331962(v=exchg.141).aspx
*first mimepart fields:
*
* Basic fields:
* Sender
* Subject
* Message-ID
* Recipient
*
* Extended fields:
* On-Behalf-Of
* To
* Cc
* Bcc
*
* Expanded and Forwarded Fields:
* Expanded
* Forwarded
*
*
* Examples:
* To: garrett.gelb@spqa2.local, Expanded: Warmfarben@spqa2.local
* To: xaviera.xanthic@spqa2.local, Expanded: Dunkelfarben@spqa2.local
* Cc: arina@spqa2.local
* Cc: quelaag.quittengelb@spqa2.local
* Bcc: doerte.dunkelbraun@spqa2.local
* Sender: caul.cyal@spqa2.local
* Subject: Test im auftrag von cyan
* Message-Id: <20160720111023.00005d68@spqa2.local>
* Recipient: joel.jadegruen@spqa2.local
*
*
* */
#endif
void parse_ms_envelope(char *content, size_t content_len,
addressinfo_t * addinfo)
{
char *endl, *startl, *tmpc;
int left, n;
int sender = 0;
left = content_len;
startl = content;
/* iterate over the block */
while ((1 < left) && (endl = memchr(startl, '\n', left))) {
if ('\r' == *(endl - 1))
memset(endl - 1, 0, 2);
else
memset(endl, 0, 1);
left -= (endl - startl) + 1;
if ((n = 3) && !strncasecmp(startl, "to:", n)) {
} else if ((n = 10) && !strncasecmp(startl, "recipient:", n)) {
} else if ((n = 3) && !strncasecmp(startl, "cc:", n)) {
} else if ((n = 4) && !strncasecmp(startl, "bcc:", n)) {
} else if ((n = 7) && !strncasecmp(startl, "sender:", n)) {
sender = 1;
} else {
goto cont;
}
startl += n;
/* check if there is an extension attribute to the field */
if (memchr(startl, ',', (endl - startl))) {
if ((tmpc = strcasestr(startl, "expanded:"))) {
startl = tmpc + 9;
} else if ((tmpc = strcasestr(startl, "forwarded:"))) {
/* ignore forwarded lines */
goto cont;
} else {
debug("unknown extension field %s", startl);
}
}
/* remove leading spaces */
while (' ' == *startl)
startl++;
if (!addinfo->sender && sender) {
addinfo->sender = strdup(startl);
} else {
clist_uniadd(addinfo->recipients, startl);
}
cont:
startl = endl + 1;
}
}
int get_msrecipients(struct mailmessage *msg, addressinfo_t * addinfo)
{
char *rawcontent = NULL;
size_t rawlen;
struct mailmime *mime = NULL;
int tmpret, ret = 1;
if ((tmpret = mailmessage_get_bodystructure(msg, &msg->msg_mime))) {
debug("cant parse structure of mail id %d (%d)", msg->msg_index, tmpret);
} else if (!msg->msg_mime->mm_data.mm_message.mm_msg_mime
|| !msg->msg_mime->mm_data.mm_message.mm_msg_mime->mm_data.mm_multipart.
mm_mp_list) {
debug("mime structure doesnt look like MS-Journal");
} else if (2 >
clist_count(msg->msg_mime->mm_data.mm_message.mm_msg_mime->mm_data.
mm_multipart.mm_mp_list)) {
/* blurp */
} else if (!(mime =
clist_nth_data(msg->msg_mime->mm_data.mm_message.mm_msg_mime->mm_data.
mm_multipart.mm_mp_list, 0))) {
/* hurz */
} else if ((tmpret =
mailmessage_fetch_section(msg, mime, &rawcontent, &rawlen))) {
debug("cant fetch envelope mime content of mail id %d (%d)",
msg->msg_index, tmpret);
} else {
parse_ms_envelope(rawcontent, rawlen, addinfo);
if (0 < clist_count(addinfo->recipients))
ret = 0;
}
if (rawcontent)
mailmessage_fetch_result_free(msg, rawcontent);
return ret;
}
int check_for_msenvelope(struct mailmessage *msg)
{
char *rawcontent = NULL;
struct mailimf_fields *fields = NULL;
int ret = 1;
if (!msg)
return -1;
if ((init_msg_headerfields(msg))) {
debug("error on headerparsing");
} else if (!get_optional_field_p(msg->msg_fields, "X-MS-Journal-Report")) {
/* keine arme, keine kekse */
} else {
ret = 0;
}
if (fields)
mailimf_fields_free(fields);
if (rawcontent)
mailmessage_fetch_result_free(msg, rawcontent);
return ret;
}
/*
*
*
*
*
*/
int check_for_msjournal(struct mailmessage *msg)
{
addressinfo_t *addinfo = NULL;
int ret = 1;
struct mailmime *mime = NULL;
char *data = NULL;
size_t len;
if (clist_inlistremove(evilmails, msg->msg_uid)) {
debug("mail had problems with parsing. will do non envelope fetch");
} else if (check_for_msenvelope(msg)) {
/* no msmail */
} else if (!(addinfo = addinfo_new())) {
debug("oom in %s", __func__);
} else if (get_msrecipients(msg, addinfo)) {
debug("found journalheader but no envelope recipients in mail id %d",
msg->msg_index);
clist_uniadd(evilmails, msg->msg_uid);
} else if (!(mime =
clist_nth_data(msg->msg_mime->mm_data.mm_message.mm_msg_mime->mm_data.
mm_multipart.mm_mp_list, 1))) {
debug("no mail-mimepart found in mail id %d", msg->msg_index);
} else if ((ret = mailmessage_fetch_section(msg, mime, &data, &len))) {
debug("cant fetch mime content of mail id %d (%d)", msg->msg_index, ret);
//} else if (!(headerend = strstr(data, "\r\n\r\n"))) {
// debug("cant detect header in mime part mail id %d", msg->msg_index);
} else {
ret = deliver_lmtp(data, len, addinfo, NULL);
}
if (data)
mailmessage_fetch_result_free(msg, data);
/* } else {
//fprintf(stderr, "sender is: %s\nrecipients:\n", addinfo->sender);
//for (clistiter *iter = clist_begin(addinfo->recipients); iter;
// iter = clist_next(iter)) {
// fprintf(stderr, " %s\n", (char *) clist_content(iter));
//}
ret = deliver_msjournal_mail(addinfo, msg);
}*/
if (addinfo)
addinfo_free(addinfo);
return ret;
}
|
/**
* @file mesherror.c
* @author Sk. Mohammadul Haque
* @version 1.8.0.0
* @copyright
* Copyright (c) 2013-2021 Sk. Mohammadul Haque.
* @brief This file contains functions pertaining to handling errors.
*/
#include "../include/meshlib.h"
/** \brief Displays error message and exits
*
* \param[in] type Error type (MESH_ERR_MALLOC/MESH_ERR_SIZE_MISMATCH/MESH_ERR_FNOTOPEN)
* \return NULL
*
*/
void mesh_error(int type)
{
switch(type)
{
case MESH_ERR_MALLOC:
fprintf(stderr, "mesh: malloc error\n");
break;
case MESH_ERR_SIZE_MISMATCH:
fprintf(stderr, "mesh: dimension size mismatch\n");
break;
case MESH_ERR_FNOTOPEN:
fprintf(stderr, "mesh: can not open file\n");
break;
case MESH_ERR_INCOMPATIBLE:
fprintf(stderr, "mesh: incompatible data\n");
break;
default:
fprintf(stderr, "mesh: unknown error\n");
break;
}
exit(-1);
}
|
#include "led.h"
void LED_OPEN()
{
GPIO_ResetBits(GPIOB,GPIO_Pin_0);
}
void LED_CLOSE()
{
GPIO_SetBits(GPIOB,GPIO_Pin_0);
}
void LED_init()
{
GPIO_InitTypeDef GPIOB_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
GPIOB_InitStructure.GPIO_Pin = GPIO_Pin_0;
GPIOB_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIOB_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOB,&GPIOB_InitStructure);
GPIO_SetBits(GPIOB,GPIO_Pin_0);
}
|
0001000002000337
*/
/* inherited classes
#ifndef _OZ0001000002000064P_H_
#define _OZ0001000002000064P_H_
#define OZClassPart0001000002fffffd_0_in_0001000002000064 1
#define OZClassPart0001000002fffffe_0_in_0001000002000064 1
#define OZClassPart0001000002000336_0_in_0001000002000064 -1
#define OZClassPart0001000002000337_0_in_0001000002000064 -1
#define OZClassPart0001000002000064_0_in_0001000002000064 0
#endif _OZ0001000002000064P_H_
|
#include<GL/glut.h>
#include<stdio.h>
#include<stdlib.h>
#include<GL/gl.h>
#include<string.h>
#define safesending 2
#define packetcrashing 3
#define timeout 4
#define one 6
#define mainmenu 16
#define sendop 17
#define dx 15
#define dy 25
int window;
int flag=0;
char E[10];
GLfloat x[25];
GLfloat y[20];
GLint i,j,k;
int w,h,a,b,c,e,d,l;
void *currentfont;
void setFont(void *font)
{
currentfont=font;
}
void drawstring(float x,float y,float z,char *string) //to display text messages
{
char *c;
glRasterPos3f(x,y,z);
for(c=string;*c!='\0';c++)
{ glColor3f(0.0,0.0,0.0);
glutBitmapCharacter(currentfont,*c);
}
}
void delay()
{ j=1000;
while(j!=0)
{ j--;
i=1000;
while(i!=0)
{ i--;
}
}
}
void draw(int x1,int x2,int y1,int y2) // TO DRAW MENU box
{
glBegin(GL_QUADS);
glColor3f(1,1,0);
glVertex2i(x1,y1);
glVertex2i(x1,y2);
glVertex2i(x2,y2);
glVertex2i(x2,y1);
glEnd();
glFlush();
}
/*
void drawop(int d,int e) // TO DRAW POLYGON FOR selection a,b,c,detcMENUS
{
glBegin(GL_POLYGON);
glColor3f(0.2f,0.2f,0.7f);
glVertex2i(d+57.5,320-e);
glColor3f(0.0f,0.0f,0.0f);
glVertex2i(d+147.5,320-e);
glColor3f(0.0f,0.0f,0.0f);
glVertex2i(d+147.5,300-e);
glColor3f(0.2f,0.2f,0.7f);
glVertex2i(d+57.5,300-e);
glEnd();
glFlush();
}
*/
void text(void) // to draw the text in menu screen
{ glClear(GL_COLOR_BUFFER_BIT);
setFont(GLUT_BITMAP_HELVETICA_18);
glColor3f(0.4932,0.9996,0.0);
drawstring(165.0,407.0,1.0," Selective Repeat A R Q ");
draw(155,299,343,365);
glColor3f(0,0,0);
drawstring(165.0,350.0,1.0,"Press S: SAFE SENDING");
draw(155,299,288,310);
glColor3f(0,0,0);
drawstring(165.0,295.0,1.0,"Press P: PACKET CRASHING");
draw(155,299,233,255);
glColor3f(0,0,0);
drawstring(165.0,240.0,1.0,"Press T: TIME OUT");
draw(155,299,178,200);
glColor3f(0,0,0);
drawstring(165.0,185.0,1.0,"Press E: EXIT");
glColor3f(1.0,1.0,1.0);
drawstring(320.0,117.0,1.0,"SUBMITTED BY");
glColor3f(0.0,1.0,1.0);
drawstring(320.0,97.0,1.0, "MAHIMA M 4VP17CS028");
glColor3f(0.0,1.0,1.0);
drawstring(320.0,77.0,1.0, "NIKHIL RAJ 4VP17CS033");
glColor3f(0.0,1.0,1.0);
drawstring(320.0,57.0,1.0, "NITHEESH KUMAR 4VP17CS035");
glFlush();
}
void timer0()
{
glColor3f(1.4,1.9,0.78);
glBegin(GL_LINE_LOOP); // timer for frame 0
glVertex2f(100,120);
glVertex2f(100,130);
glVertex2f(225,130);
glVertex2f(225,120);
glEnd();
glFlush();
}
void timer1()
{
glColor3f(1,1,1);
glBegin(GL_LINE_LOOP); // timer for frame 1
glVertex2f(100,100);
glVertex2f(100,110);
glVertex2f(225,110);
glVertex2f(225,100);
glEnd();
glFlush();
}
void timer2()
{
glColor3f(1,1,1);
glBegin(GL_LINE_LOOP); // timer for frame 2
glVertex2f(100,80);
glVertex2f(100,90);
glVertex2f(225,90);
glVertex2f(225,80);
glEnd();
glFlush();
}
void timer3()
{
glColor3f(1,1,1);
glBegin(GL_LINE_LOOP); // timer for frame 3
glVertex2f(360,120);
glVertex2f(360,130);
glVertex2f(485,130);
glVertex2f(485,120);
glEnd();
glFlush();
}
void timer4()
{
glColor3f(1.4,1.9,0.78);
glBegin(GL_LINE_LOOP); // timer for frame 4
glVertex2f(360,100);
glVertex2f(360,110);
glVertex2f(485,110);
glVertex2f(485,100);
glEnd();
glFlush();
}
void timer(float k,float l,float m,float n)
{
glColor3f(1,1,0);
glBegin(GL_POLYGON); // to call timer functions
glVertex2f(l,m);
glVertex2f(l,n);
glVertex2f(l+k,n);
glVertex2f(l+k,m);
glEnd();
glFlush();
}
void move1() //MOVEMENT OF FRAME 0 (in safe sending)
{
float i,j,temp=0.3,k=0;
glColor3f(1.0,0.8,0.4);
setFont(GLUT_BITMAP_HELVETICA_18);
drawstring(30.0,125.0,1.0," Timer 0");
timer0();
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0f,1.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 0 sending ...........");
for(j=0;j<4;j=j+temp) //movement of data packet within the frame
{ glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(55,265-j);glVertex2i(55,280-j);glVertex2i(60,280-j);glVertex2i(60,265-j);
glEnd();
glFlush();
glColor3f(0,0,0); // to remove traces create movement of frame in black
glBegin(GL_QUADS);
glVertex2i(55,265-j);glVertex2i(55,280-j);glVertex2i(60,280-j);glVertex2i(60,265-j);
glEnd();
glFlush();
}
for(j=0;j<60;j=j+temp) //movement of data packet from top to down
{ glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(55,238-j);glVertex2i(55,253-j);glVertex2i(60,253-j);glVertex2i(60,238-j);
glEnd();
glFlush();
k+=0.05;
timer(k,102.5,122,128);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(55,238-j);glVertex2i(55,253-j);glVertex2i(60,253-j);glVertex2i(60,238-j);
glEnd();
glFlush();
}
for(i=0;i<231;i=i+temp) //movement of data packet sidewise
{ glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(60+i,178);glVertex2i(60+i,183);glVertex2i(75+i,183);glVertex2i(75+i,178);
glEnd();
glFlush();
k+=0.05;
timer(k,102.5,122,128);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(60+i,178);glVertex2i(60+i,183);glVertex2i(75+i,183);glVertex2i(75+i,178);
glEnd();
glFlush();
}
for(j=0;j<60;j=j+temp) //to move the packet from bottom to top
{
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(305,178+j);glVertex2i(305,193+j);glVertex2i(310,193+j);glVertex2i(310,178+j);
glEnd();
glFlush();
k+=0.05;
timer(k,102.5,122,128);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(305,178+j);glVertex2i(305,193+j);glVertex2i(310,193+j);glVertex2i(310,178+j);
glEnd();
glFlush();
}
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(0.0f,0.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 0 sending ...........");
glColor3f(1.0,1.0,0.0);
drawstring(58.5,300.0,1.0,"FRAME 0 sent");
// delay();
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(0.0,0.0,0.0);
drawstring(58.5,300.0,1.0,"FRAME 0 sent");
}
void move2() // SIMULTANEOUS MOVEMENT OF ACK 1 AND FRAME 1(in safe sending)
{
float i,j,temp=0.3,k=0,l=0;
setFont(GLUT_BITMAP_HELVETICA_18);
glColor3f(1.0,0.8,0.4);
drawstring(30.0,105.0,1.0," Timer 1");
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0f,1.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 1 sending ...........");
glColor3f(1.0f,1.0f,0.0f);
drawstring(370.0,300.0,1.0,"........... sending ACK1 ");
timer1();
for(j=0;j<4;j=j+temp) //movement of data packet within the frame
{ glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(320,265-j);glVertex2i(320,275-j);glVertex2i(325,275-j);glVertex2i(325,265-j);
glEnd();
glFlush();
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(70,265-j);glVertex2i(70,280-j);glVertex2i(75,280-j);glVertex2i(75,265-j);
glEnd();
glFlush();
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(70,265-j);glVertex2i(70,280-j);glVertex2i(75,280-j);glVertex2i(75,265-j);
glEnd();
glFlush();
glColor3f(0,0,0); // to remove traces create movement of frame in black
glBegin(GL_QUADS);
glVertex2i(320,265-j);glVertex2i(320,275-j);glVertex2i(325,275-j);glVertex2i(325,265-j);
glEnd();
glFlush();
}
for(j=0;j<60;j=j+temp) //movement of data packet from top to down
{ glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(320,228-j);glVertex2i(320,238-j);glVertex2i(325,238-j);glVertex2i(325,228-j);
glEnd();
glFlush();
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(70,238-j);glVertex2i(70,253-j);glVertex2i(75,253-j);glVertex2i(75,238-j);
glEnd();
glFlush();
k+=0.05;
timer(k,156.5,122,128);
timer(k,102.5,102,108);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(320,228-j);glVertex2i(320,238-j);glVertex2i(325,238-j);glVertex2i(325,228-j);
glEnd();
glFlush();
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(70,238-j);glVertex2i(70,253-j);glVertex2i(75,253-j);glVertex2i(75,238-j);
glEnd();
glFlush();
}
for(i=0;i<235;i=i+temp) //movement of data packet sidewise
{ glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(310-i,168);glVertex2i(310-i,173);glVertex2i(320-i,173);glVertex2i(320-i,168);
glEnd();
glFlush();
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(70+i,178);glVertex2i(70+i,183);glVertex2i(85+i,183);glVertex2i(85+i,178);
glEnd();
glFlush();
k+=0.05;
timer(k,156.5,122,128);
timer(k,102.5,102,108);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(310-i,168);glVertex2i(310-i,173);glVertex2i(320-i,173);glVertex2i(320-i,168);
glEnd();
glFlush();
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(70+i,178);glVertex2i(70+i,183);glVertex2i(85+i,183);glVertex2i(85+i,178);
glEnd();
glFlush();
}
for(j=0;j<63;j=j+temp) //to move the packet from bottom to top
{
glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(70,168+j);glVertex2i(70,178+j);glVertex2i(75,178+j);glVertex2i(75,168+j);
glEnd();
glFlush();
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(320,178+j);glVertex2i(320,193+j);glVertex2i(325,193+j);glVertex2i(325,178+j);
glEnd();
glFlush();
k+=0.05;
timer(k,156.5,122,128);
timer(k,102.5,102,108);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(70,168+j);glVertex2i(70,178+j);glVertex2i(75,178+j);glVertex2i(75,168+j);
glEnd();
glFlush();
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(320,178+j);glVertex2i(320,193+j);glVertex2i(325,193+j);glVertex2i(325,178+j);
glEnd();
glFlush();
}
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(0.0f,0.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 1 sending ...........");
glColor3f(0.0f,0.0f,0.0f);
drawstring(370.0,300.0,1.0,"........... sending ACK1 ");
glColor3f(1.0,1.0,0.0);
drawstring(58.5,300.0,1.0,"FRAME 1 sent ");
glColor3f(1.0f,1.0f,0.0f);
drawstring(370.0,300.0,1.0,"ACK1 Recieved ");
glColor3f(0.0,0.0,0.0);
glBegin(GL_POLYGON);
glVertex2f(10,115);
glVertex2f(10,135);
glVertex2f(230,135);
glVertex2f(230,115);
glEnd();
glFlush();
setFont(GLUT_BITMAP_HELVETICA_18);
glColor3f(1.0,0.8,0.4);
drawstring(80.0,125.0,1.0," Frame 0 sent successfully");
// delay();
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(0.0,0.0,0.0);
drawstring(58.5,300.0,1.0,"FRAME 1 sent ");
glColor3f(0.0f,0.0f,0.0f);
drawstring(370.0,300.0,1.0,"ACK1 Recieved ");
}
void move3() // MOVEMENT OF FRAME 2 ( FRAME 2 lost in packet crashing)
{
float i,j,temp=0.3;
float k=0;
timer2();
glColor3f(1.0,0.8,0.4);
setFont(GLUT_BITMAP_HELVETICA_18);
drawstring(30.0,85.0,1.0,"Timer 2");
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0f,1.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 2 sending ...........");
for(j=0;j<4;j=j+temp) //movement of data packet within the frame
{
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(85,265-j);glVertex2i(85,280-j);glVertex2i(90,280-j);glVertex2i(90,265-j);
glEnd();
glFlush();
k+=0.05;
timer(k,102.5,82,88);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(85,265-j);glVertex2i(85,280-j);glVertex2i(90,280-j);glVertex2i(90,265-j);
glEnd();
glFlush();
}
for(j=0;j<60;j=j+temp) //movement of data packet from top to down
{ glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(85,238-j);glVertex2i(85,253-j);glVertex2i(90,253-j);glVertex2i(90,238-j);
glEnd();
glFlush();
k+=0.05;
timer(k,102.5,82,88);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(85,238-j);glVertex2i(85,253-j);glVertex2i(90,253-j);glVertex2i(90,238-j);
glEnd();
glFlush();
}
for(i=0;i<167;i=i+temp) //movement of data packet sidewise
{ glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(85+i,178);glVertex2i(85+i,183);glVertex2i(100+i,183);glVertex2i(100+i,178);
glEnd();
glFlush();
k+=0.05;
timer(k,102.5,82,88);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(85+i,178);glVertex2i(85+i,183);glVertex2i(100+i,183);glVertex2i(100+i,178);
glEnd();
glFlush();
}
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(0.0f,0.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 2 sending ...........");
glColor3f(1.0f,1.0f,0.0f);
drawstring(185.0,165.0,1.0,"FRAME 2 lost");
//glColor3f(1.0f,1.0f,0.0f);
//drawstring(160.0,265.0,1.0,"FRAME 2 lost");
// delay();
glColor3f(0.0f,0.0f,0.0f);
drawstring(185.0,265.0,1.0,"FRAME 2 lost");
}
void move4() // RESENDING OF FRAME 2 (in packet crashing)
{
float i,j,temp=0.3;
timer2();
timer4();
timer3();
float k=0;
float p=0;
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0f,1.0f,1.0f);
drawstring(58.5,300.0,1.0,"FRAME 2 Resending ...........");
for(j=0;j<4;j=j+temp) //movement of data packet within the frame
{ glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(85,265-j);glVertex2i(85,280-j);glVertex2i(90,280-j);glVertex2i(90,265-j);
glEnd();
glFlush();
k+=0.03;
timer(k,102.5,82,88);
glColor3f(0,0,0); // to remove traces create movement of frame in black
glBegin(GL_QUADS);
glVertex2i(85,265-j);glVertex2i(85,280-j);glVertex2i(90,280-j);glVertex2i(90,265-j);
glEnd();
glFlush();
}
for(j=0;j<60;j=j+temp) //movement of data packet from top to down
{ glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(85,238-j);glVertex2i(85,253-j);glVertex2i(90,253-j);glVertex2i(90,238-j);
glEnd();
glFlush();
k+=0.03;
timer(k,102.5,82,88);
timer(k,396.5,102,108);
p+=0.01;
timer(p,430.5,122,128);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(85,238-j);glVertex2i(85,253-j);glVertex2i(90,253-j);glVertex2i(90,238-j);
glEnd();
glFlush();
}
for(i=0;i<231;i=i+temp) //movement of data packet sidewise
{ glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(85+i,178);glVertex2i(85+i,183);glVertex2i(100+i,183);glVertex2i(100+i,178);
glEnd();
glFlush();
k+=0.03;
timer(k,102.5,82,88);
timer(k,396.5,102,108);
p+=0.01;
timer(p,430.5,122,128);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(85+i,178);glVertex2i(85+i,183);glVertex2i(100+i,183);glVertex2i(100+i,178);
glEnd();
glFlush();
}
for(j=0;j<60;j=j+temp) //to move the packet from bottom to top
{
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(335,178+j);glVertex2i(335,193+j);glVertex2i(340,193+j);glVertex2i(340,178+j);
glEnd();
glFlush();
k+=0.03;
timer(k,102.5,82,88);
timer(k,396.5,102,108);
p+=0.01;
timer(p,430.5,122,128);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(335,178+j);glVertex2i(335,193+j);glVertex2i(340,193+j);glVertex2i(340,178+j);
glEnd();
glFlush();
}
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(0.0f,0.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 2 Resending ...........");
glColor3f(1.0f,1.0f,1.0f);
drawstring(58.5,300.0,1.0,"FRAME 2 sent");
// delay();
glColor3f(0.0f,0.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 2 sent");
}
void move5() // sending of frame 3
{
float i,j,temp=0.3;
timer2();
timer3();
float k=0,l=0;
glColor3f(1.0,0.8,0.4);
setFont(GLUT_BITMAP_HELVETICA_18);
drawstring(320.0,125.0,1.0,"Timer 3");
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0f,1.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 3 sending ...........");
for(j=0;j<4;j=j+temp) //movement of data packet within the frame
{
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(100,265-j);glVertex2i(100,280-j);glVertex2i(105,280-j);glVertex2i(105,265-j);
glEnd();
glFlush();
k+=0.03;
timer(k,136.5,82,88);
glColor3f(0,0,0); // to remove traces create movement of frame in black
glBegin(GL_QUADS);
glVertex2i(100,265-j);glVertex2i(100,280-j);glVertex2i(105,280-j);glVertex2i(105,265-j);
glEnd();
glFlush();
}
for(j=0;j<50;j=j+temp) //movement of data packet from top to down
{
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(100,238-j);glVertex2i(100,253-j);glVertex2i(105,253-j);glVertex2i(105,238-j);
glEnd();
glFlush();
k+=0.03;
timer(k,136.5,82,88);
timer(k,362.5,122,128);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(100,238-j);glVertex2i(100,253-j);glVertex2i(105,253-j);glVertex2i(105,238-j);
glEnd();
glFlush();
}
for(i=0;i<235;i=i+temp) //movement of data packet sidewise
{
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(100+i,183);glVertex2i(100+i,188);glVertex2i(115+i,188);glVertex2i(115+i,183);
glEnd();
glFlush();
k+=0.03;
timer(k,136.5,82,88);
timer(k,362.5,122,128);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(100+i,183);glVertex2i(100+i,188);glVertex2i(115+i,188);glVertex2i(115+i,183);
glEnd();
glFlush();
}
for(j=0;j<55;j=j+temp) //to move the packet from bottom to top
{
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(350,183+j);glVertex2i(350,198+j);glVertex2i(355,198+j);glVertex2i(355,183+j);
glEnd();
glFlush();
k+=0.03;
timer(k,136.5,82,88);
timer(k,362.5,122,128);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(350,183+j);glVertex2i(350,198+j);glVertex2i(355,198+j);glVertex2i(355,183+j);
glEnd();
glFlush();
}
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(0.0f,0.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 3 sending ...........");
glColor3f(0.0f,0.0f,0.0f);
drawstring(370.0,300.0,1.0,"........... sending NAK2 ");
glColor3f(1.0,1.0,0.0);
drawstring(58.5,300.0,1.0,"FRAME 3 sent ");
// delay();
glColor3f(0.0,0.0,0.0);
drawstring(58.5,300.0,1.0,"FRAME 3 sent ");
}
void move6() // RESENDING OF FRAME 1(in packet crashing)
{
float i,j,temp=0.3;
glBegin(GL_LINE_LOOP);
glColor3f(0,0,0);
glVertex2f(100,120);
glVertex2f(225,120);
glVertex2f(225,130);
glVertex2f(100,130);
glEnd();
glFlush();
glBegin(GL_POLYGON);
glColor3f(0,0,0);
glVertex2f(100,120);
glVertex2f(225,120);
glVertex2f(225,130);
glVertex2f(100,130);
glEnd();
glFlush();
for(j=0;j<4;j=j+temp) //movement of data packet within the frame
{ glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(70,265-j);glVertex2i(70,280-j);glVertex2i(75,280-j);glVertex2i(75,265-j);
glEnd();
glFlush();
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(70,265-j);glVertex2i(70,280-j);glVertex2i(75,280-j);glVertex2i(75,265-j);
glEnd();
glFlush();
}
for(j=0;j<60;j=j+temp) //movement of data packet from top to down
{ glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(70,238-j);glVertex2i(70,253-j);glVertex2i(75,253-j);glVertex2i(75,238-j);
glEnd();
glFlush();
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0f,1.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 1 sending .....");
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(70,238-j);glVertex2i(70,253-j);glVertex2i(75,253-j);glVertex2i(75,238-j);
glEnd();
glFlush();
}
for(i=0;i<231;i=i+temp) //movement of data packet sidewise
{ glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(70+i,178);glVertex2i(70+i,183);glVertex2i(85+i,183);glVertex2i(85+i,178);
glEnd();
glFlush();
glColor3f(1.0f,1.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 1 resending ...................");
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(70+i,178);glVertex2i(70+i,183);glVertex2i(85+i,183);glVertex2i(85+i,178);
glEnd();
glFlush();
}
for(j=0;j<60;j=j+temp) //to move the packet from bottom to top
{
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(320,178+j);glVertex2i(320,193+j);glVertex2i(325,193+j);glVertex2i(325,178+j);
glEnd();
glFlush();
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0f,1.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 0 sending ...............................");
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(320,178+j);glVertex2i(320,193+j);glVertex2i(325,193+j);glVertex2i(325,178+j);
glEnd();
glFlush();
}
glColor3f(1.0,1.0,1.0);
drawstring(70,268.0,0.0,"1");
glColor3f(1.0,1.0,1.0);
drawstring(85,268.0,0.0,"2");
glColor3f(1.0,1.0,1.0);
drawstring(100,268.0,0.0,"3");
glColor3f(1.0,1.0,1.0);
drawstring(320,268.0,0.0,"1");
glColor3f(1.0,1.0,1.0);
drawstring(365,268.0,0.0,"4");
}
void move7() // MOVEMENT OF ACK 4 (in packet crashing)
{
float i,j,temp=0.3;
for(j=0;j<4;j=j+temp) //movement of data packet within the frame
{ glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(365,265-j);glVertex2i(365,275-j);glVertex2i(370,275-j);glVertex2i(370,265-j);
glEnd();
glFlush();
glColor3f(0,0,0); // to remove traces create movement of frame in black
glBegin(GL_QUADS);
glVertex2i(365,265-j);glVertex2i(365,275-j);glVertex2i(370,275-j);glVertex2i(370,265-j);
glEnd();
glFlush();
}
for(j=0;j<50;j=j+temp) //movement of data packet from top to down
{ glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(365,228-j);glVertex2i(365,238-j);glVertex2i(370,238-j);glVertex2i(370,228-j);
glEnd();
glFlush();
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(365,228-j);glVertex2i(365,238-j);glVertex2i(370,238-j);glVertex2i(370,228-j);
glEnd();
glFlush();
}
for(i=0;i<235;i=i+temp) //movement of data packet sidewise
{
glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(355-i,178);glVertex2i(355-i,183);glVertex2i(365-i,183);glVertex2i(365-i,178);
glEnd();
glFlush();
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0f,1.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 1 resending ...................");
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(355-i,178);glVertex2i(355-i,183);glVertex2i(365-i,183);glVertex2i(365-i,178);
glEnd();
glFlush();
}
for(j=0;j<55;j=j+temp) //to move the packet from bottom to top
{
glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(115,178+j);glVertex2i(115,188+j);glVertex2i(120,188+j);glVertex2i(120,178+j);
glEnd();
glFlush();
glColor3f(1.0f,1.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 0 sending ...............................");
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(115,178+j);glVertex2i(115,188+j);glVertex2i(120,188+j);glVertex2i(120,178+j);
glEnd();
glFlush();
}
glColor3f(1.0,1.0,1.0);
drawstring(365,268.0,0.0,"4");
}
void move8() // MOVEMENT OF ACK 4 (in packet crashing)
{
float i,j,temp=0.3;
float k=0;
timer1();
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0f,1.0f,0.0f);
drawstring(370.0,300.0,1.0,"........... sending ACK2 ");
for(j=0;j<4;j=j+temp) //movement of data packet within the frame
{ glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(335,265-j);glVertex2i(335,275-j);glVertex2i(340,275-j);glVertex2i(340,265-j);
glEnd();
glFlush();
glColor3f(0,0,0); // to remove traces create movement of frame in black
glBegin(GL_QUADS);
glVertex2i(335,265-j);glVertex2i(335,275-j);glVertex2i(340,275-j);glVertex2i(340,265-j);
glEnd();
glFlush();
}
for(j=0;j<50;j=j+temp) //movement of data packet from top to down
{ glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(335,228-j);glVertex2i(335,238-j);glVertex2i(340,238-j);glVertex2i(340,228-j);
glEnd();
glFlush();
k+=0.05;
timer(k,136.5,102,108);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(335,228-j);glVertex2i(335,238-j);glVertex2i(340,238-j);glVertex2i(340,228-j);
glEnd();
glFlush();
}
for(i=0;i<235;i=i+temp) //movement of data packet sidewise
{
glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(325-i,178);glVertex2i(325-i,183);glVertex2i(335-i,183);glVertex2i(335-i,178);
glEnd();
glFlush();
k+=0.05;
timer(k,136.5,102,108);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(325-i,178);glVertex2i(325-i,183);glVertex2i(335-i,183);glVertex2i(335-i,178);
glEnd();
glFlush();
}
for(j=0;j<55;j=j+temp) //to move the packet from bottom to top
{
glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(85,178+j);glVertex2i(85,188+j);glVertex2i(90,188+j);glVertex2i(90,178+j);
glEnd();
glFlush();
k+=0.05;
timer(k,136.5,102,108);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(85,178+j);glVertex2i(85,188+j);glVertex2i(90,188+j);glVertex2i(90,178+j);
glEnd();
glFlush();
}
glColor3f(0.0f,0.0f,0.0f);
drawstring(370.0,300.0,1.0,"........... sending ACK2 ");
glColor3f(0.0,0.0,0.0);
glBegin(GL_POLYGON);
glVertex2f(10,95);
glVertex2f(10,115);
glVertex2f(230,115);
glVertex2f(230,95);
glEnd();
glFlush();
setFont(GLUT_BITMAP_HELVETICA_18);
glColor3f(1.0,0.8,0.4);
drawstring(80.0,105.0,1.0," Frame 1 sent successfully");
// delay();
}
void move9() // MOVEMENT OF ACK 1 (in safe sending)
{
float i,j,temp=0.5;
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(0.0f,0.0f,0.0f);
drawstring(58.5,300.0,1.0," FRAME 0 sent");
glColor3f(0.0f,1.0f,0.0f);
drawstring(370.0,300.0,1.0," .... sending ACK1 ");
for(j=0;j<4;j=j+temp) //movement of data packet within the frame
{ glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(320,265-j);glVertex2i(320,275-j);glVertex2i(325,275-j);glVertex2i(325,265-j);
glEnd();
glFlush();
glColor3f(0,0,0); // to remove traces create movement of frame in black
glBegin(GL_QUADS);
glVertex2i(320,265-j);glVertex2i(320,275-j);glVertex2i(325,275-j);glVertex2i(325,265-j);
glEnd();
glFlush();
}
for(j=0;j<60;j=j+temp) //movement of data packet from top to down
{ glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(320,228-j);glVertex2i(320,238-j);glVertex2i(325,238-j);glVertex2i(325,228-j);
glEnd();
glFlush();
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(0.0f,0.0f,0.0f);
drawstring(370.0,300.0,1.0," .... sending ACK1 ");
glColor3f(0.0f,1.0f,0.0f);
drawstring(370.0,300.0,1.0,".............. sending ACK1 ");
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(320,228-j);glVertex2i(320,238-j);glVertex2i(325,238-j);glVertex2i(325,228-j);
glEnd();
glFlush();
}
for(i=0;i<235;i=i+temp) //movement of data packet sidewise
{ glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(310-i,168);glVertex2i(310-i,173);glVertex2i(320-i,173);glVertex2i(320-i,168);
glEnd();
glFlush();
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(0.0f,0.0f,0.0f);
drawstring(370.0,300.0,1.0,".............. sending ACK1 ");
glColor3f(0.0f,1.0f,0.0f);
drawstring(370.0,300.0,1.0,"........................... sending ACK1 ");
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(310-i,168);glVertex2i(310-i,173);glVertex2i(320-i,173);glVertex2i(320-i,168);
glEnd();
glFlush();
}
for(j=0;j<63;j=j+temp) //to move the packet from bottom to top
{
glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(70,168+j);glVertex2i(70,178+j);glVertex2i(75,178+j);glVertex2i(75,168+j);
glEnd();
glFlush();
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(0.0f,0.0f,0.0f);
drawstring(370.0,300.0,1.0,"........................... sending ACK1 ");
glColor3f(0.0f,1.0f,0.0f);
drawstring(58.5,300.0,1.0,"..................................... sending ACK1 ");
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(70,168+j);glVertex2i(70,178+j);glVertex2i(75,178+j);glVertex2i(75,168+j);
glEnd();
glFlush();
}
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(0.0f,0.0f,0.0f);
drawstring(58.5,300.0,1.0,"..................................... sending ACK1 ");
glColor3f(0.0f,1.0f,0.0f);
drawstring(58.5,300.0,1.0," ACK1 received");
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0,1.0,1.0);
drawstring(55,268.0,0.0,"0");
glColor3f(1.0,1.0,1.0);
drawstring(320,268.0,0.0,"1");
// delay();
glColor3f(0.0f,0.0f,0.0f);
drawstring(58.5,300.0,1.0," ACK1 received");
}
void move10() // SIMULTANEOUS MOVEMENT OF NAK 2 AS FRAME 2 IS LOST AND FRAME 4 (in packet crashing)
{
float i,j,temp=0.3;
timer2();
timer3();
timer4();
float k=0;
glColor3f(1.0,0.8,0.4);
setFont(GLUT_BITMAP_HELVETICA_18);
drawstring(320.0,105.0,1.0,"Timer 4");
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0f,1.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 4 sending ...........");
glColor3f(1.0f,1.0f,0.0f);
drawstring(370.0,300.0,1.0,"........... sending NAK2 ");
for(j=0;j<4;j=j+temp) //movement of data packet within the frame
{ glColor3f(1,1,0);
glBegin(GL_QUADS);
glVertex2i(335,265-j);glVertex2i(335,275-j);glVertex2i(340,275-j);glVertex2i(340,265-j);
glEnd();
glFlush();
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(115,265-j);glVertex2i(115,280-j);glVertex2i(120,280-j);glVertex2i(120,265-j);
glEnd();
glFlush();
glColor3f(0,0,0); // to remove traces create movement of frame in black
glBegin(GL_QUADS);
glVertex2i(335,265-j);glVertex2i(335,275-j);glVertex2i(340,275-j);glVertex2i(340,265-j);
glEnd();
glFlush();
glColor3f(0,0,0); // to remove traces create movement of frame in black
glBegin(GL_QUADS);
glVertex2i(115,265-j);glVertex2i(115,280-j);glVertex2i(120,280-j);glVertex2i(120,265-j);
glEnd();
glFlush();
}
for(j=0;j<50;j=j+temp) //movement of data packet from top to down
{ glColor3f(1,1,0);
glBegin(GL_QUADS);
glVertex2i(335,228-j);glVertex2i(335,238-j);glVertex2i(340,238-j);glVertex2i(340,228-j);
glEnd();
glFlush();
k+=0.03;
timer(k,170.5,82,88);
timer(k,396.5,122,128);
timer(k,362.5,102,108);
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(115,238-j);glVertex2i(115,253-j);glVertex2i(120,253-j);glVertex2i(120,238-j);
glEnd();
glFlush();
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(335,228-j);glVertex2i(335,238-j);glVertex2i(340,238-j);glVertex2i(340,228-j);
glEnd();
glFlush();
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(115,238-j);glVertex2i(115,253-j);glVertex2i(120,253-j);glVertex2i(120,238-j);
glEnd();
glFlush();
}
for(i=0;i<235;i=i+temp) //movement of data packet sidewise
{ glColor3f(1,1,0);
glBegin(GL_QUADS);
glVertex2i(325-i,178);glVertex2i(325-i,183);glVertex2i(335-i,183);glVertex2i(335-i,178);
glEnd();
glFlush();
k+=0.03;
timer(k,170.5,82,88);
timer(k,396.5,122,128);
timer(k,362.5,102,108);
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(115+i,183);glVertex2i(115+i,188);glVertex2i(130+i,188);glVertex2i(130+i,183);
glEnd();
glFlush();
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(325-i,178);glVertex2i(325-i,183);glVertex2i(335-i,183);glVertex2i(335-i,178);
glEnd();
glFlush();
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(115+i,183);glVertex2i(115+i,188);glVertex2i(130+i,188);glVertex2i(130+i,183);
glEnd();
glFlush();
}
for(j=0;j<55;j=j+temp) //to move the packet from bottom to top
{
glColor3f(1,1,0);
glBegin(GL_QUADS);
glVertex2i(85,178+j);glVertex2i(85,188+j);glVertex2i(90,188+j);glVertex2i(90,178+j);
glEnd();
glFlush();
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(365,183+j);glVertex2i(365,198+j);glVertex2i(370,198+j);glVertex2i(370,183+j);
glEnd();
glFlush();
k+=0.03;
timer(k,170.5,82,88);
timer(k,396.5,122,128);
timer(k,362.5,102,108);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(85,178+j);glVertex2i(85,188+j);glVertex2i(90,188+j);glVertex2i(90,178+j);
glEnd();
glFlush();
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(365,183+j);glVertex2i(365,198+j);glVertex2i(370,198+j);glVertex2i(370,183+j);
glEnd();
glFlush();
}
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(0.0f,0.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 4 sending ...........");
glColor3f(0.0f,0.0f,0.0f);
drawstring(370.0,300.0,1.0,"........... sending NAK2 ");
glColor3f(1.0,1.0,0.0);
drawstring(58.5,300.0,1.0,"FRAME 4 sent ");
glColor3f(1.0f,1.0f,0.0f);
drawstring(370.0,300.0,1.0,"NAK2 Recieved ");
// delay();
glColor3f(0.0,0.0,0.0);
drawstring(58.5,300.0,1.0,"FRAME 4 sent ");
glColor3f(0.0f,0.0f,0.0f);
drawstring(370.0,300.0,1.0,"NAK2 Recieved ");
}
void move11() // MOVEMENT OF ACK 4 (in packet crashing)
{
float i,j,temp=0.3;
timer2();
timer3();
timer4();
float k=0;
float p=0;
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0f,1.0f,0.0f);
drawstring(370.0,300.0,1.0,"........... sending ACK4 ");
for(j=0;j<4;j=j+temp) //movement of data packet within the frame
{ glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(380,265-j);glVertex2i(380,275-j);glVertex2i(385,275-j);glVertex2i(385,265-j);
glEnd();
glFlush();
k+=0.03;
timer(k,136.5,82,88);
glColor3f(0,0,0); // to remove traces create movement of frame in black
glBegin(GL_QUADS);
glVertex2i(380,265-j);glVertex2i(380,275-j);glVertex2i(385,275-j);glVertex2i(385,265-j);
glEnd();
glFlush();
}
for(j=0;j<50;j=j+temp) //movement of data packet from top to down
{ glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(380,228-j);glVertex2i(380,238-j);glVertex2i(385,238-j);glVertex2i(385,228-j);
glEnd();
glFlush();
k+=0.03;
timer(k,136.5,82,88);
timer(k,431.5,102,108);
p+=0.01;
timer(p,442,122,128);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(380,228-j);glVertex2i(380,238-j);glVertex2i(385,238-j);glVertex2i(385,228-j);
glEnd();
glFlush();
}
for(i=0;i<235;i=i+temp) //movement of data packet sidewise
{
glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(370-i,178);glVertex2i(370-i,183);glVertex2i(380-i,183);glVertex2i(380-i,178);
glEnd();
glFlush();
k+=0.03;
timer(k,136.5,82,88);
timer(k,431.5,102,108);
p+=0.01;
timer(p,442,122,128);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(370-i,178);glVertex2i(370-i,183);glVertex2i(380-i,183);glVertex2i(380-i,178);
glEnd();
glFlush();
}
for(j=0;j<55;j=j+temp) //to move the packet from bottom to top
{
glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(130,178+j);glVertex2i(130,188+j);glVertex2i(135,188+j);glVertex2i(135,178+j);
glEnd();
glFlush();
k+=0.03;
timer(k,136.5,82,88);
timer(k,431.5,102,108);
p+=0.01;
timer(p,442,122,128);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(130,178+j);glVertex2i(130,188+j);glVertex2i(135,188+j);glVertex2i(135,178+j);
glEnd();
glFlush();
}
glColor3f(1.0,1.0,1.0);
drawstring(365,268.0,0.0,"4");
glColor3f(0.0f,0.0f,0.0f);
drawstring(370.0,300.0,1.0,"........... sending ACK4 ");
glColor3f(1.0f,1.0f,0.0f);
drawstring(370.0,300.0,1.0,"NAK4 Recieved ");
// delay();
glColor3f(0.0f,0.0f,0.0f);
drawstring(370.0,300.0,1.0,"NAK4 Recieved ");
}
void move12()
{
float i,j,temp=0.3;
float k=0;
timer1();
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0f,1.0f,0.0f);
drawstring(370.0,300.0,1.0,"........... sending ACK2 ");
for(j=0;j<4;j=j+temp) //movement of data packet within the frame
{ glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(335,265-j);glVertex2i(335,275-j);glVertex2i(340,275-j);glVertex2i(340,265-j);
glEnd();
glFlush();
glColor3f(0,0,0); // to remove traces create movement of frame in black
glBegin(GL_QUADS);
glVertex2i(335,265-j);glVertex2i(335,275-j);glVertex2i(340,275-j);glVertex2i(340,265-j);
glEnd();
glFlush();
}
for(j=0;j<50;j=j+temp) //movement of data packet from top to down
{ glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(335,228-j);glVertex2i(335,238-j);glVertex2i(340,238-j);glVertex2i(340,228-j);
glEnd();
glFlush();
k+=0.03;
timer(k,136.5,102,108);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(335,228-j);glVertex2i(335,238-j);glVertex2i(340,238-j);glVertex2i(340,228-j);
glEnd();
glFlush();
}
for(i=0;i<65;i=i+temp) //movement of data packet sidewise
{
glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(325-i,178);glVertex2i(325-i,183);glVertex2i(335-i,183);glVertex2i(335-i,178);
glEnd();
glFlush();
k+=0.03;
timer(k,136.5,102,108);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(325-i,178);glVertex2i(325-i,183);glVertex2i(335-i,183);glVertex2i(335-i,178);
glEnd();
glFlush();
}
glColor3f(0.0f,0.0f,0.0f);
drawstring(370.0,300.0,1.0,"........... sending ACK2 ");
}
void move13() // SIMULTANEOUS MOVEMENT OF ACK 1 AND FRAME 1(in safe sending)
{
float i,j,temp=0.5;
float k=0;
timer1();
timer2();
setFont(GLUT_BITMAP_HELVETICA_18);
glColor3f(1.0,0.8,0.4);
drawstring(30.0,105.0,1.0," Timer 1");
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0f,1.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 1 Resending ...........");
glColor3f(1.0f,1.0f,0.0f);
drawstring(370.0,300.0,1.0,"........... sending ACK3 ");
for(j=0;j<4;j=j+temp) //movement of data packet within the frame
{ glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(350,265-j);glVertex2i(350,275-j);glVertex2i(355,275-j);glVertex2i(355,265-j);
glEnd();
glFlush();
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(70,265-j);glVertex2i(70,280-j);glVertex2i(75,280-j);glVertex2i(75,265-j);
glEnd();
glFlush();
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(70,265-j);glVertex2i(70,280-j);glVertex2i(75,280-j);glVertex2i(75,265-j);
glEnd();
glFlush();
glColor3f(0,0,0); // to remove traces create movement of frame in black
glBegin(GL_QUADS);
glVertex2i(350,265-j);glVertex2i(350,275-j);glVertex2i(355,275-j);glVertex2i(355,265-j);
glEnd();
glFlush();
}
for(j=0;j<60;j=j+temp) //movement of data packet from top to down
{ glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(350,228-j);glVertex2i(350,238-j);glVertex2i(355,238-j);glVertex2i(355,228-j);
glEnd();
glFlush();
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(70,238-j);glVertex2i(70,253-j);glVertex2i(75,253-j);glVertex2i(75,238-j);
glEnd();
glFlush();
k+=0.03;
timer(k,102.5,102,108);
timer(k,148.5,82,88);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(350,228-j);glVertex2i(350,238-j);glVertex2i(355,238-j);glVertex2i(355,228-j);
glEnd();
glFlush();
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(70,238-j);glVertex2i(70,253-j);glVertex2i(75,253-j);glVertex2i(75,238-j);
glEnd();
glFlush();
}
for(i=0;i<235;i=i+temp) //movement of data packet sidewise
{ glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(340-i,168);glVertex2i(340-i,173);glVertex2i(350-i,173);glVertex2i(350-i,168);
glEnd();
glFlush();
k+=0.03;
timer(k,102.5,102,108);
timer(k,148.5,82,88);
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(70+i,178);glVertex2i(70+i,183);glVertex2i(85+i,183);glVertex2i(85+i,178);
glEnd();
glFlush();
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(340-i,168);glVertex2i(340-i,173);glVertex2i(350-i,173);glVertex2i(350-i,168);
glEnd();
glFlush();
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(70+i,178);glVertex2i(70+i,183);glVertex2i(85+i,183);glVertex2i(85+i,178);
glEnd();
glFlush();
}
for(j=0;j<63;j=j+temp) //to move the packet from bottom to top
{
glColor3f(0,1,1);
glBegin(GL_QUADS);
glVertex2i(100,168+j);glVertex2i(100,178+j);glVertex2i(105,178+j);glVertex2i(105,168+j);
glEnd();
glFlush();
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(320,178+j);glVertex2i(320,193+j);glVertex2i(325,193+j);glVertex2i(325,178+j);
glEnd();
glFlush();
k+=0.03;
timer(k,102.5,102,108);
timer(k,148.5,82,88);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(100,168+j);glVertex2i(100,178+j);glVertex2i(105,178+j);glVertex2i(105,168+j);
glEnd();
glFlush();
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(320,178+j);glVertex2i(320,193+j);glVertex2i(325,193+j);glVertex2i(325,178+j);
glEnd();
glFlush();
}
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(0.0f,0.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 1 Resending ...........");
glColor3f(0.0f,0.0f,0.0f);
drawstring(370.0,300.0,1.0,"........... sending ACK3 ");
glColor3f(1.2,0.6,1.6);
drawstring(315.0,248.0,1.0,"DUPLICATE " );//Frame 1");
glColor3f(1.2,0.6,1.6);
drawstring(310.0,238.0,1.0,"FRAME 1 Discarded ");
glFlush();
}
void move14() // RESENDING OF FRAME 2 (in packet crashing)
{
float i,j,temp=0.3;
timer2();
float k=0;
float q=0;
glColor3f(1.0,0.8,0.4);
setFont(GLUT_BITMAP_HELVETICA_18);
drawstring(30.0,85.0,1.0,"Timer 2");
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0f,1.0f,1.0f);
drawstring(58.5,300.0,1.0,"FRAME 2 Sending ...........");
for(j=0;j<4;j=j+temp) //movement of data packet within the frame
{ glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(85,265-j);glVertex2i(85,280-j);glVertex2i(90,280-j);glVertex2i(90,265-j);
glEnd();
glFlush();
k+=0.07;
timer(k,145.5,102,108);
q+=0.04;
timer(q,102.5,82,88);
glColor3f(0,0,0); // to remove traces create movement of frame in black
glBegin(GL_QUADS);
glVertex2i(85,265-j);glVertex2i(85,280-j);glVertex2i(90,280-j);glVertex2i(90,265-j);
glEnd();
glFlush();
}
for(j=0;j<60;j=j+temp) //movement of data packet from top to down
{ glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(85,238-j);glVertex2i(85,253-j);glVertex2i(90,253-j);glVertex2i(90,238-j);
glEnd();
glFlush();
k+=0.07;
timer(k,145.5,102,108);
q+=0.04;
timer(q,102.5,82,88);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(85,238-j);glVertex2i(85,253-j);glVertex2i(90,253-j);glVertex2i(90,238-j);
glEnd();
glFlush();
}
for(i=0;i<231;i=i+temp) //movement of data packet sidewise
{ glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(85+i,178);glVertex2i(85+i,183);glVertex2i(100+i,183);glVertex2i(100+i,178);
glEnd();
glFlush();
k+=0.07;
timer(k,145.5,102,108);
q+=0.04;
timer(q,102.5,82,88);
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0f,1.0f,1.0f);
drawstring(58.5,300.0,1.0,"FRAME 2 Sending ...........");
// drawstring(160.0,370.0,1.0,"FRAME 2 sending...................");
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(85+i,178);glVertex2i(85+i,183);glVertex2i(100+i,183);glVertex2i(100+i,178);
glEnd();
glFlush();
}
for(j=0;j<60;j=j+temp) //to move the packet from bottom to top
{
glColor3f(1,0,0);
glBegin(GL_QUADS);
glVertex2i(335,178+j);glVertex2i(335,193+j);glVertex2i(340,193+j);glVertex2i(340,178+j);
glEnd();
glFlush();
k+=0.05;
timer(k,145.5,102,108);
q+=0.04;
timer(q,102.5,82,88);
setFont(GLUT_BITMAP_HELVETICA_12);
/////glColor3f(1.0f,1.0f,0.0f);
/////drawstring(160.0,365.0,1.0,"FRAME 0 sending ...............................");
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2i(335,178+j);glVertex2i(335,193+j);glVertex2i(340,193+j);glVertex2i(340,178+j);
glEnd();
glFlush();
}
glColor3f(0.0f,0.0f,0.0f);
drawstring(58.5,300.0,1.0,"FRAME 2 Sending ...........");
// delay();
glColor3f(0,0,0);
glBegin(GL_POLYGON);
glVertex2f(0,98);
glVertex2f(0,115);
glVertex2f(228,115);
glVertex2f(228,98);
glEnd();
glFlush();
//delay();
setFont(GLUT_BITMAP_HELVETICA_18);
glColor3f(1.0,0.8,0.4);
drawstring(80.0,105.0,1.0," TIME OUT !!");
glFlush();
delay();
delay();
setFont(GLUT_BITMAP_HELVETICA_18);
glColor3f(0,0,0);
drawstring(80.0,105.0,1.0," TIME OUT !!");
glFlush();
glColor3f(1.0,0.8,0.4);
drawstring(228.0,105.0,1.0," TIMER 1 restarted");
glFlush();
}
void slide(GLint maxx,GLint maxy,GLfloat x0,GLfloat y0) // TO DRAW WINDOWS (Rectangular Mesh) arrary type
{
for(i=0;i<maxx;i++)
x[i]=x0+i*dx;
for(j=0;j<maxy;j++)
y[j]=y0+j*dy;
for(i=0;i<maxx-1;i++)
for(j=0;j<maxy-1;j++)
{
glBegin(GL_LINE_LOOP);
glVertex2f(x[i],y[j]);
glVertex2f(x[i],y[j+1]);
glVertex2f(x[i+1],y[j+1]);
glVertex2f(x[i+1],y[j]);
glEnd();
glFlush();
}
}
void computer(int a) // to draw the sender and receiver computers
{
glColor3f(0.3,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(a+90,450-10-20);
glVertex2f(a+93,453-10-20);
glVertex2f(a+93,402-10-20);
glVertex2f(a+90,400-10-20);
glEnd();
glFlush();
glColor3f(0.7,0.0,0.0);
glBegin(GL_LINE_LOOP);
glVertex2f(a+90,450-10-20);
glVertex2f(a+93,453-10-20);
glVertex2f(a+93,402-10-20);
glVertex2f(a+90,400-10-20);
glEnd();
glFlush();
glColor3f(0.3,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(a+25,450-10-20);
glVertex2f(a+28,453-10-20);
glVertex2f(a+93,453-10-20);
glVertex2f(a+90,450-10-20);
glEnd();
glFlush();
glColor3f(0.7,0.0,0.0);
glBegin(GL_LINE_LOOP);
glVertex2f(a+25,450-10-20);
glVertex2f(a+28,453-10-20);
glVertex2f(a+93,453-10-20);
glVertex2f(a+90,450-10-20);
glEnd();
glFlush();
glColor3f(0.7,0.0,0.0);//monitor
glBegin(GL_LINE_LOOP);
glVertex2f(a+25,400-10-20);
glVertex2f(a+25,450-10-20);
glVertex2f(a+90,450-10-20);
glVertex2f(a+90,400-10-20);
glEnd();
glFlush();
glColor3f(0,0,0.09);// INNER monitor
glBegin(GL_QUADS);
glVertex2f(a+27,402-10-20);
glVertex2f(a+27,448-10-20);
glVertex2f(a+88,448-10-20);
glVertex2f(a+88,402-10-20);
glEnd();
glFlush();
glColor3f(0.0,1,0.0);// INNER monitor
glBegin(GL_LINE_LOOP);
glVertex2f(a+27,402-10-20);
glVertex2f(a+27,448-10-20);
glVertex2f(a+88,448-10-20);
glVertex2f(a+88,402-10-20);
glEnd();
glFlush();
glBegin(GL_LINE_STRIP); //middle screen design
glColor3f(0.7,0.7,0.7);
glVertex2i(a+88,448-10-20);
glVertex2i(a+58,426-10-20);
glVertex2i(a+64,426-10-20);
glVertex2i(a+27,402-10-20);
glEnd();
//STAND
glColor3f(0.5,0.5,0.5);
glBegin(GL_QUADS);
glVertex2f(a+64,390-10-20);
glVertex2f(a+64,400-10-20);
glVertex2f(a+52,400-10-20);
glVertex2f(a+52,390-10-20);
glEnd();
glFlush();
glColor3f(0.7,0,0);
glBegin(GL_LINE_LOOP);
glVertex2f(a+64,390-10-20);
glVertex2f(a+64,400-10-20);
glVertex2f(a+52,400-10-20);
glVertex2f(a+52,390-10-20);
glEnd();
glFlush();
//keyboard
glColor3f(0.09,0.0,0.0); //OUTLINE
glBegin(GL_QUADS);
glVertex2f(a+25,390-10-20);
glVertex2f(a+10,375-10-20);
glVertex2f(a+105,375-10-20);
glVertex2f(a+90,390-10-20);
glEnd();
glFlush();
glColor3f(0.7,0.0,0.0);
glBegin(GL_LINE_LOOP);//OUTLINE OUTLINE
glVertex2f(a+25,390-10-20);
glVertex2f(a+10,375-10-20);
glVertex2f(a+105,375-10-20);
glVertex2f(a+90,390-10-20);
glEnd();
glFlush();
glColor3f(0.3,0.0,0.0);//SHADE
glBegin(GL_QUADS);
glVertex2f(a+11,375-10-20);
glVertex2f(a+11,371-10-20);
glVertex2f(a+104,371-10-20);
glVertex2f(a+104,375-10-20);
glEnd();
glFlush();
glColor3f(0.7,0.0,0.0);//SHADE LINE
glBegin(GL_LINE_STRIP);
glVertex2f(a+11,375-10-20);
glVertex2f(a+11,371-10-20);
glVertex2f(a+104,371-10-20);
glVertex2f(a+104,375-10-20);
glEnd();
glFlush();
glColor3f(0.5,0.5,0.5);
glBegin(GL_LINES);
//horizontal
glVertex2f(a+22+5,387-10-20);
glVertex2f(a+93-5,387-10-20);
glVertex2f(a+18+4,383-10-20);
glVertex2f(a+97-4,383-10-20);
glVertex2f(a+14+3,379-10-20);
glVertex2f(a+101-3,379-10-20);
//vertical
glVertex2f(a+38,390-10-2-20);
glVertex2f(a+29,375-10+2-20);
glVertex2f(a+51,390-10-2-20);
glVertex2f(a+48,375-10+2-20);
glVertex2f(a+64,390-10-2-20);
glVertex2f(a+67,375-10+2-20);
glVertex2f(a+77,390-10-2-20);
glVertex2f(a+86,375-10+2-20);
glVertex2f(a+38,390-10-2-20);
glVertex2f(a+29,375-10+2-20);
glEnd();
glFlush();
glColor3f(0.0,1,0.0);
glBegin(GL_LINE_LOOP);//OUTLINE OUTLINE GREEN
glVertex2f(a+25+2,390-10-2-20);
glVertex2f(a+10+5,375-10+2-20);
glVertex2f(a+105-5,375-10+2-20);
glVertex2f(a+90-2,390-10-2-20);
glEnd();
glFlush();
//cpu
/*
glColor3f(0.09,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(100,390-10);
glVertex2f(135,390-10);
glVertex2f(135,450-10);
glVertex2f(100,450-10);
glEnd();
glFlush();
*/
glColor3f(0.7,0.7,0.7);//CPU MIDDLE LINE
glBegin(GL_LINES);
glVertex2f(102,430-10-20);
glVertex2f(133,430-10-20);
glEnd();
glFlush();
glColor3f(0.3,0.0,0.0);//CPU UP SHADE
glBegin(GL_QUADS);
glVertex2f(100,450-10-20);
glVertex2f(105,455-10-20);
glVertex2f(140,455-10-20);
glVertex2f(135,450-10-20);
glEnd();
glFlush();
glColor3f(0.3,0.0,0.0);
glBegin(GL_QUADS); //CPU RIGHT SHADE
glVertex2f(135,450-10-20);
glVertex2f(140,455-10-20);
glVertex2f(140,395-10-20);
glVertex2f(135,390-10-20);
glEnd();
glFlush();
glColor3f(0.7,0.0,0.0);
glBegin(GL_LINE_LOOP); //CPU OUTLINE
glVertex2f(100,390-10-20);
glVertex2f(135,390-10-20);
glVertex2f(135,450-10-20);
glVertex2f(100,450-10-20);
glEnd();
glFlush();
glColor3f(0,0.5,0.0);
glBegin(GL_LINE_LOOP); //CPU OUTLINE GREEN
glVertex2f(102,392-10-20);
glVertex2f(133,392-10-20);
glVertex2f(133,448-10-20);
glVertex2f(102,448-10-20);
glEnd();
glFlush();
glColor3f(0.7,0.0,0.0);
glBegin(GL_LINE_LOOP); //UPSHADE OUTLINE
glVertex2f(100,450-10-20);
glVertex2f(105,455-10-20);
glVertex2f(140,455-10-20);
glVertex2f(135,450-10-20);
glEnd();
glFlush();
glColor3f(0.7,0.0,0.0);
glBegin(GL_LINE_LOOP); //SIDE SHADE OUTLINE
glVertex2f(135,450-10-20);
glVertex2f(140,455-10-20);
glVertex2f(140,395-10-20);
glVertex2f(135,390-10-20);
glEnd();
glFlush();
glColor3f(0,0,0.1);
glBegin(GL_QUADS); //CD DRIVE
glVertex2f(105,440-10-20);
glVertex2f(105,445-10-20);
glVertex2f(130,445-10-20);
glVertex2f(130,440-10-20);
glEnd();
glFlush();
glColor3f(0,0.3,0);
glBegin(GL_LINE_LOOP); //CD DIVE OUTLINE
glVertex2f(105,440-10-20);
glVertex2f(105,445-10-20);
glVertex2f(130,445-10-20);
glVertex2f(130,440-10-20);
glEnd();
glFlush();
glColor3f(0.5,0.5,0.5);
glBegin(GL_QUADS); //POWER BUTTUON
glVertex2f(115,407-10-20);
glVertex2f(115,413-10-20);
glVertex2f(121,413-10-20);
glVertex2f(121,407-10-20);
glEnd();
glFlush();
glColor3f(0,0.3,0);
glBegin(GL_LINE_LOOP); //POWER BUTTON OUTLINE
glVertex2f(115,407-10-20);
glVertex2f(115,413-10-20);
glVertex2f(121,413-10-20);
glVertex2f(121,407-10-20);
glEnd();
glFlush();
//cpu right
/*
glColor3f(0.09,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(100,390-10);
glVertex2f(135,390-10);
glVertex2f(135,450-10);
glVertex2f(100,450-10);
glEnd();
glFlush();
*/
glColor3f(0.7,0.7,0.7);//right CPU MIDDLE LINE
glBegin(GL_LINES);
glVertex2f(255+102,430-10-20);
glVertex2f(255+133,430-10-20);
glEnd();
glFlush();
glColor3f(0.3,0.0,0.0);//right CPU UP SHADE
glBegin(GL_QUADS);
glVertex2f(255+100,450-10-20);
glVertex2f(255+105,455-10-20);
glVertex2f(255+140,455-10-20);
glVertex2f(255+135,450-10-20);
glEnd();
glFlush();
glColor3f(0.3,0.0,0.0);
glBegin(GL_QUADS); //right CPU RIGHT SHADE
glVertex2f(255+135,450-10-20);
glVertex2f(255+140,455-10-20);
glVertex2f(255+140,395-10-20);
glVertex2f(255+135,390-10-20);
glEnd();
glFlush();
glColor3f(0.7,0.0,0.0);
glBegin(GL_LINE_LOOP); //right CPU OUTLINE
glVertex2f(255+100,390-10-20);
glVertex2f(255+135,390-10-20);
glVertex2f(255+135,450-10-20);
glVertex2f(255+100,450-10-20);
glEnd();
glFlush();
glColor3f(0,0.5,0.0);
glBegin(GL_LINE_LOOP); //right CPU OUTLINE GREEN
glVertex2f(255+102,392-10-20);
glVertex2f(255+133,392-10-20);
glVertex2f(255+133,448-10-20);
glVertex2f(255+102,448-10-20);
glEnd();
glFlush();
glColor3f(0.7,0.0,0.0);
glBegin(GL_LINE_LOOP); //right UPSHADE OUTLINE
glVertex2f(255+100,450-10-20);
glVertex2f(255+105,455-10-20);
glVertex2f(255+140,455-10-20);
glVertex2f(255+135,450-10-20);
glEnd();
glFlush();
glColor3f(0.7,0.0,0.0);
glBegin(GL_LINE_LOOP); //right SIDE SHADE OUTLINE
glVertex2f(255+135,450-10-20);
glVertex2f(255+140,455-10-20);
glVertex2f(255+140,395-10-20);
glVertex2f(255+135,390-10-20);
glEnd();
glFlush();
glColor3f(0,0,0.1);
glBegin(GL_QUADS); //right CD DRIVE
glVertex2f(255+105,440-10-20);
glVertex2f(255+105,445-10-20);
glVertex2f(255+130,445-10-20);
glVertex2f(255+130,440-10-20);
glEnd();
glFlush();
glColor3f(0,0.3,0);
glBegin(GL_LINE_LOOP); //right CD DIVE OUTLINE
glVertex2f(255+105,440-10-20);
glVertex2f(255+105,445-10-20);
glVertex2f(255+130,445-10-20);
glVertex2f(255+130,440-10-20);
glEnd();
glFlush();
glColor3f(0.5,0.5,0.5);
glBegin(GL_QUADS); //right POWER BUTTUON
glVertex2f(255+115,407-10-20);
glVertex2f(255+115,413-10-20);
glVertex2f(255+121,413-10-20);
glVertex2f(255+121,407-10-20);
glEnd();
glFlush();
glColor3f(0,0.4,0);
glBegin(GL_LINE_LOOP); //right POWER BUTTON OUTLINE
glVertex2f(255+115,407-10-20);
glVertex2f(255+115,413-10-20);
glVertex2f(255+121,413-10-20);
glVertex2f(255+121,407-10-20);
glEnd();
glFlush();
glColor3f(0,0,0.1);
glBegin(GL_QUADS); //Connection
glVertex2f(145,433-20-20);
glVertex2f(145,430-20-20);
glVertex2f(345,430-20-20);
glVertex2f(345,433-20-20);
glEnd();
glFlush();
glColor3f(0,0,0.4);
glBegin(GL_LINE_LOOP); //Connection outline
glVertex2f(145,433-20-20);
glVertex2f(145,430-20-20);
glVertex2f(345,430-20-20);
glVertex2f(345,433-20-20);
glEnd();
glFlush();
glColor3f(1,0,0);
glBegin(GL_LINES); //line top
glVertex2f(0,420+20);
glVertex2f(500,420+20);
glEnd();
glFlush();
glColor3f(1,0,0);
glBegin(GL_LINES); //line bottom
glVertex2f(0,300+20);
glVertex2f(500,300+20);
glEnd();
glFlush();
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0,1.0,1.0);
drawstring(435.0,450.5,1.0,"NAK"); //frame indicators
glFlush();
glColor3f(1.0,1.0,1.0);
drawstring(435.0,465.5,1.0,"ACK ");
glFlush();
glColor3f(1.0,1.0,1.0);
drawstring(435.0,480.5,1.0,"DATA FRAMES");
glFlush();
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON); //df red
glVertex2f(430,480);
glVertex2f(415,480);
glVertex2f(415,485);
glVertex2f(430,485);
glEnd();
glFlush();
glColor3f(0,1.0,1.0);
glBegin(GL_POLYGON);
glVertex2f(430,465);//ack L.blue
glVertex2f(415,465);
glVertex2f(415,470);
glVertex2f(430,470);
glEnd();
glFlush();
glColor3f(1.0,1.0,0.0);
glBegin(GL_POLYGON);
glVertex2f(430,450);//nak yellow
glVertex2f(415,450);
glVertex2f(415,455);
glVertex2f(430,455);
glEnd();
glFlush();
}
void computers()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0f,1.0f,1.0f);
setFont(GLUT_BITMAP_HELVETICA_12);
drawstring(425.0,449.0-20,1.0,"COM-2");
computer(380);
glColor3f(1.0f,1.0f,1.0f);
setFont(GLUT_BITMAP_HELVETICA_12);
drawstring(40.0,449.0-20,1.0,"COM-1");
computer(0);
}
void draw6(void) // text for keyboard interaction
{
glColor3f(1.0,01.0,01.0);
glBegin(GL_POLYGON);
glVertex2f(359,113-66);
glVertex2f(359,130-66);
glVertex2f(435,130-66);
glVertex2f(435,113-66);
glEnd();
glFlush();
glBegin(GL_POLYGON);
glVertex2f(359,107-66);
glVertex2f(359,89-66);
glVertex2f(435,89-66);
glVertex2f(435,107-66);
glEnd();
glFlush();
glColor3f(0,0,0);
setFont(GLUT_BITMAP_HELVETICA_18);
drawstring(361.0,119-66.0,1.0,"Press C:Continue");
glColor3f(0,0,0);
drawstring(361.0,93-66,1.0,"Press E:Exit");
glFlush();
}
void draw3(int m,int l) // DRAWING OF SAFE SENDING
{
//Sender site initial window
glClear(GL_COLOR_BUFFER_BIT);
computers();
//computer1();
//computer2();
setFont(GLUT_BITMAP_HELVETICA_18);
glColor3f(0.4932,0.9996,0.0);
drawstring(m+30.0,430-20.0,1.0,E);
glColor3f(1.6,1.9,1.2);
setFont(GLUT_BITMAP_HELVETICA_18);
drawstring(180.0,465.5,1.0,"S A F E S E N D I N G");
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0,1.0,1.0);
drawstring(55,268.0,0.0,"0");
glColor3f(1.0,1.0,1.0);
drawstring(69,268.0,0.0," 1");
glColor3f(1.0,1.0,1.0);
drawstring(84,268.0,0.0,"2");
glColor3f(1.0,1.0,1.0);
drawstring(99,268.0,0.0,"3");
glColor3f(1.0,1.0,1.0);
drawstring(114,268.0,0.0,"4");
glColor3f(1.0,1.0,1.0);
drawstring(130,268.0,0.0,"5");
glColor3f(1.0,1.0,1.0);
drawstring(147,268.0,0.0,"6");
glColor3f(1.0,1.0,1.0);
drawstring(163,268.0,0.0,"7");
glColor3f(1.0,1.0,1.0);
drawstring(177,268.0,0.0,"0");
glColor3f(1.0,1.0,1.0);
drawstring(305,268.0,0.0,"0");
glColor3f(1.0,1.0,1.0);
drawstring(320,268.0,0.0,"1");
glColor3f(1.0,1.0,1.0);
drawstring(334,268.0,0.0," 2");
glColor3f(1.0,1.0,1.0);
drawstring(349,268.0,0.0,"3");
glColor3f(1.0,1.0,1.0);
drawstring(364,268.0,0.0,"4");
glColor3f(1.0,1.0,1.0);
drawstring(379,268.0,0.0,"5");
glColor3f(1.0,1.0,1.0);
drawstring(394,268.0,0.0,"6");
glColor3f(1.0,1.0,1.0);
drawstring(409,268.0,0.0,"7");
glColor3f(1.0,1.0,1.0);
drawstring(424,268.0,0.0,"0");
//SENDER SIDE
glColor3f(0.0,0.0,1.0); // Initial set of frames in BLUE color
slide(10,2,50,260);
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // Send window in WHITE color
glVertex2f(50,255);
glVertex2f(110,255);
glVertex2f(110,290);
glVertex2f(50,290);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0);
slide(10,2,300,260); // Initial set of frames in BLUE color
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // initial sending frames in red
slide(5,2,50,260);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // receiver window in red
slide(5,2,300,260);
glEnd();
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // receiver window in WHITE color
glVertex2f(300,255);
glVertex2f(360,255);
glVertex2f(360,290);
glVertex2f(300,290);
glEnd();
glFlush();
// delay();
glColor3f(0.0,1.0,0.0); //Frame 0 sent and becoming green
slide(2,2,50,260);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // sliding the window and becoming green
slide(4,2,65,260);
glEnd();
glFlush();
move1(); // movement of data packet
glColor3f(0.0,0.0,1.0); // sliding the window and becoming green
slide(2,2,300,260);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // 4th frame red
slide(2,2,360,260);
glEnd();
glFlush();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP); // To remove initial WHITE window trace
glVertex2f(300,255);
glVertex2f(360,255);
glVertex2f(360,290);
glVertex2f(300,290);
glEnd();
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(315,255);
glVertex2f(375,255);
glVertex2f(375,290);
glVertex2f(315,290);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0); // To remove traces
glBegin(GL_LINES);
glVertex2f(300,260);
glVertex2f(300,285);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // To remove traces
glBegin(GL_LINES);
glVertex2f(360,260);
glVertex2f(360,285);
glEnd();
glFlush();
glColor3f(0.0,1.0,0.0); // sliding the window and becoming green
slide(2,2,65,260);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0); // sliding the window and becoming green
slide(1,2,300,260);
glEnd();
glFlush();
move2();
setFont(GLUT_BITMAP_HELVETICA_18);
glColor3f(0.4932,0.9996,0.0);
drawstring(l+110.0,430.0-20,1.0,E);
setFont(GLUT_BITMAP_HELVETICA_18);
glColor3f(0,0,0);
drawstring(m+30.0,430-20.0,1.0,E);
glColor3f(1.0,1.0,1.0);
drawstring(69,268.0,0.0," 1");
glColor3f(1.0,1.0,1.0);
drawstring(55,268.0,0.0,"0");
glColor3f(1.0,1.0,1.0);
drawstring(320,268.0,0.0,"1");
glColor3f(0.0,0.0,1.0); // sliding the window and becoming blue
slide(2,2,50,260);
glEnd();
glFlush();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP); // To remove initial WHITE window trace
glVertex2f(50,255);
glVertex2f(50,290);
glVertex2f(110,290);
glVertex2f(110,255);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // sliding the window and becoming blue
slide(2,2,110,260);
glBegin(GL_LINES);
glVertex2f(110,260);
glVertex2f(110,285);
glEnd();
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(65,255);
glVertex2f(65,290);
glVertex2f(125,290);
glVertex2f(125,255);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0); //to remove traces
glBegin(GL_LINES);
glVertex2f(50,260);
glVertex2f(50,285);
glEnd();
glFlush();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(315,255);
glVertex2f(375,255);
glVertex2f(375,290);
glVertex2f(315,290);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0);
glBegin(GL_LINES);
glVertex2f(315,260);
glVertex2f(315,285);
glVertex2f(375,260);
glVertex2f(375,285);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0); // sliding the window and becoming green
slide(3,2,300,260);
glEnd();
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(330,255);
glVertex2f(330,290);
glVertex2f(390,290);
glVertex2f(390,255);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // sliding the window and becoming green
slide(2,2,375,260);
glEnd();
glFlush();
move8();
setFont(GLUT_BITMAP_HELVETICA_18);
glColor3f(1.0,1.0,1.0);
drawstring(m+30.0,430.0-20,1.0,"message sent");
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0,1.0,1.0);
drawstring(334,268.0,0.0," 2");
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP); // remove window trace
glVertex2f(65,255);
glVertex2f(65,290);
glVertex2f(125,290);
glVertex2f(125,255);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // sliding the window and becoming green
slide(5,2,80,260);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0); // sliding the window and becoming green
slide(3,2,50,260);
glEnd();
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(80,255);
glVertex2f(80,290);
glVertex2f(140,290);
glVertex2f(140,255);
glEnd();
glFlush();
delay();
}
void draw4(int m,int l) // DRAWING OF PACKET CRASHNG
{
//second screen for lost packet
//delay();
glClear(GL_COLOR_BUFFER_BIT);
computers();
//computer1();
//computer2();
glColor3f(1.6,1.9,1.2);
setFont(GLUT_BITMAP_HELVETICA_18);
drawstring(180.0,465.5,1.0,"P A C K E T C R A S H I N G");
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0,1.0,1.0);
drawstring(56,268.0,0.0,"0");
glColor3f(1.0,1.0,1.0);
drawstring(70,268.0,0.0,"1");
glColor3f(1.0,1.0,1.0);
drawstring(85,268.0,0.0,"2");
glColor3f(1.0,1.0,1.0);
drawstring(100,268.0,0.0,"3");
glColor3f(1.0,1.0,1.0);
drawstring(114,268.0,0.0," 4");
glColor3f(1.0,1.0,1.0);
drawstring(130,268.0,0.0,"5");
glColor3f(1.0,1.0,1.0);
drawstring(147,268.0,0.0,"6");
glColor3f(1.0,1.0,1.0);
drawstring(163,268.0,0.0,"7");
glColor3f(1.0,1.0,1.0);
drawstring(177,268.0,0.0,"0");
glColor3f(1.0,1.0,1.0);
drawstring(305,268.0,0.0,"0");
glColor3f(1.0,1.0,1.0);
drawstring(320,268.0,0.0,"1");
glColor3f(1.0,1.0,1.0);
drawstring(334,268.0,0.0," 2");
glColor3f(1.0,1.0,1.0);
drawstring(349,268.0,0.0,"3");
glColor3f(1.0,1.0,1.0);
drawstring(365,268.0,0.0,"4");
glColor3f(1.0,1.0,1.0);
drawstring(379,268.0,0.0," 5");
glColor3f(1.0,1.0,1.0);
drawstring(394,268.0,0.0,"6");
glColor3f(1.0,1.0,1.0);
drawstring(409,268.0,0.0,"7");
glColor3f(1.0,1.0,1.0);
drawstring(424,268.0,0.0,"0");
glColor3f(0.0,0.0,1.0);
slide(10,2,50,260); // Initial set of frames in BLUE color
glColor3f(1.0,0.0,0.0);
slide(5,2,50,260); // red frames in window
glEnd();
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // send window in WHITE color
glVertex2f(50,255);
glVertex2f(50,290);
glVertex2f(110,290);
glVertex2f(110,255);
glEnd();
glFlush();
//Reciver Window
glColor3f(0.0,0.0,1.0);
slide(10,2,300,260); // Initial set of frames in BLUE color
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0);
slide(5,2,300,260); // red frames in window
glEnd();
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(300,255);
glVertex2f(360,255);
glVertex2f(360,290);
glVertex2f(300,290);
glEnd();
glFlush();
// delay();
glColor3f(0.0,1.0,0.0);
slide(2,2,50,260); // red frames in window
glEnd();
glFlush();
move1();
glColor3f(0.0,0.0,1.0); // sliding the window and becoming green
slide(2,2,300,260);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // 4th frame red
slide(2,2,360,260);
glEnd();
glFlush();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP); // To remove initial WHITE window trace
glVertex2f(300,255);
glVertex2f(360,255);
glVertex2f(360,290);
glVertex2f(300,290);
glEnd();
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(315,255);
glVertex2f(375,255);
glVertex2f(375,290);
glVertex2f(315,290);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0); // To remove traces
glBegin(GL_LINES);
glVertex2f(300,260);
glVertex2f(300,285);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // To remove traces
glBegin(GL_LINES);
glVertex2f(360,260);
glVertex2f(360,285);
glEnd();
glFlush();
glColor3f(0.0,1.0,0.0); // sliding the window and becoming green
slide(2,2,65,260);
glEnd();
glFlush();
move2();
glColor3f(0.0,0.0,1.0); // sliding the window and becoming blue
slide(2,2,50,260);
glEnd();
glFlush();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP); // To remove initial WHITE window trace
glVertex2f(50,255);
glVertex2f(50,290);
glVertex2f(110,290);
glVertex2f(110,255);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // sliding the window and becoming blue
slide(2,2,110,260);
glBegin(GL_LINES);
glVertex2f(110,260);
glVertex2f(110,285);
glEnd();
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(65,255);
glVertex2f(65,290);
glVertex2f(125,290);
glVertex2f(125,255);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0); //to remove traces
glBegin(GL_LINES);
glVertex2f(50,260);
glVertex2f(50,285);
glEnd();
glFlush();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(315,255);
glVertex2f(375,255);
glVertex2f(375,290);
glVertex2f(315,290);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0);
glBegin(GL_LINES);
glVertex2f(315,260);
glVertex2f(315,285);
glVertex2f(375,260);
glVertex2f(375,285);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0); // sliding the window and becoming green
slide(3,2,300,260);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // sliding the window and becoming green
slide(2,2,375,260);
glEnd();
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(330,255);
glVertex2f(330,290);
glVertex2f(390,290);
glVertex2f(390,255);
glEnd();
glFlush();
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0,1.0,1.0);
drawstring(56,268.0,0.0,"0");
glColor3f(1.0,1.0,1.0);
drawstring(320,268.0,0.0,"1");
move8();
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0,1.0,1.0);
drawstring(70,268.0,0.0,"1");
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP); // remove window trace
glVertex2f(65,255);
glVertex2f(65,290);
glVertex2f(125,290);
glVertex2f(125,255);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // sliding the window and becoming green
slide(5,2,80,260);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0); // sliding the window and becoming green
slide(3,2,50,260);
glEnd();
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(80,255);
glVertex2f(80,290);
glVertex2f(140,290);
glVertex2f(140,255);
glEnd();
glFlush();
glColor3f(0.0,1.0,0.0);
slide(2,2,80,260);
glFlush();
move3();
glColor3f(1.0,0.0,0.0); //packet crashing
glBegin(GL_POLYGON);
glVertex2f(240,168);
glVertex2f(255,168);
glVertex2f(260,178);
glVertex2f(265,168);
glVertex2f(280,168);
glVertex2f(267.5,163);
glVertex2f(280,153);
glVertex2f(260,163);
glVertex2f(240,153);
glVertex2f(252.5,163);
glEnd();
glFlush();
glColor3f(0.0,0.0,0.0); //to remove traces
glBegin(GL_TRIANGLES);
glVertex2f(240,168);
glVertex2f(260,178);
glVertex2f(255,168);
glEnd();
glFlush();
glBegin(GL_TRIANGLES);
glVertex2f(240,168);
glVertex2f(252.5,163);
glVertex2f(240,153);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0);
slide(2,2,65,260);
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINES);
glVertex2f(80,260);
glVertex2f(80,285);
glEnd();
glColor3f(0.0,1.0,0.0);
slide(2,2,95,260);
glFlush();
move5();
glColor3f(1.0,1.0,1.0);
drawstring(334,268.0,0.0," 2");
glColor3f(0.0,1.0,0.0);
slide(2,2,345,260);
glFlush();
glColor3f(0.0,1.0,0.0);
slide(2,2,110,260);
glFlush();
move10();
glColor3f(0.0,1.0,0.0);
slide(2,2,360,260);
glFlush();
glColor3f(0,0,0);
glBegin(GL_POLYGON); //to remove timer trace
glVertex2f(100,80);
glVertex2f(100,90);
glVertex2f(225,90);
glVertex2f(225,80);
glEnd();
glFlush();
glColor3f(0.0,0.0,0.0); //packet crashing
glBegin(GL_POLYGON);
glVertex2f(240,168);
glVertex2f(255,168);
glVertex2f(260,178);
glVertex2f(265,168);
glVertex2f(280,168);
glVertex2f(267.5,163);
glVertex2f(280,153);
glVertex2f(260,163);
glVertex2f(240,153);
glVertex2f(252.5,163);
glEnd();
glFlush();
glColor3f(0.0,0.0,0.0); //to remove traces
glBegin(GL_TRIANGLES);
glVertex2f(240,168);
glVertex2f(260,178);
glVertex2f(255,168);
glEnd();
glFlush();
glBegin(GL_TRIANGLES);
glVertex2f(240,168);
glVertex2f(252.5,163);
glVertex2f(240,153);
glEnd();
glFlush();
glColor3f(0.0f,0.0f,0.0f);
drawstring(185.0,165.0,1.0,"FRAME 2 lost");
move4();
glColor3f(1.0,1.0,1.0);
drawstring(334,268.0,0.0," 2");
glColor3f(0.0,1.0,0.0);
slide(2,2,330,260);
glFlush();
//delay();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(330,255);
glVertex2f(330,290);
glVertex2f(390,290);
glVertex2f(390,255);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0);
slide(6,2,300,260);
glFlush();
glColor3f(1.0,0.0,0.0);
slide(5,2,375,260);
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(375,255);
glVertex2f(375,290);
glVertex2f(435,290);
glVertex2f(435,255);
glEnd();
glFlush();
move11();
glColor3f(1.0,1.0,1.0);
drawstring(85,268.0,0.0,"2");
glColor3f(1.0,1.0,1.0);
drawstring(100,268.0,0.0,"3");
glColor3f(1.0,1.0,1.0);
drawstring(114,268.0,0.0," 4");
glColor3f(1.0,1.0,1.0);
drawstring(379,268.0,0.0," 5");
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(80,255);
glVertex2f(80,290);
glVertex2f(140,290);
glVertex2f(140,255);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0);
slide(6,2,50,260);
glFlush();
glColor3f(1.0,0.0,0.0);
slide(5,2,125,260);
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(125,255);
glVertex2f(125,290);
glVertex2f(185,290);
glVertex2f(185,255);
glEnd();
glFlush();
}
void draw5(int m, int l) // to show time out
{
//Sender site initial window
glClear(GL_COLOR_BUFFER_BIT);
computers();
//computer1();
//computer2();
glColor3f(0.0,0.0,1.0);
slide(10,2,50,260); // Initial set of frames in BLUE color
glFlush();
glColor3f(0.0,0.0,1.0); // active line indicator
/*
glBegin(GL_POLYGON);
glVertex2f(59.5+m,348);
glVertex2f(59.5+m,342);
glVertex2f(155.5+l,342);
glVertex2f(155.5+l,348);
glEnd();
glFlush();*/
glColor3f(1.6,1.9,1.2);
setFont(GLUT_BITMAP_HELVETICA_18);
drawstring(180.0,465.5,1.0,"T I M E O U T");
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0,1.0,1.0);
drawstring(55,268.0,0.0,"0");
glColor3f(1.0,1.0,1.0);
drawstring(69,268.0,0.0," 1");
glColor3f(1.0,1.0,1.0);
drawstring(84,268.0,0.0," 2");
glColor3f(1.0,1.0,1.0);
drawstring(99,268.0,0.0,"3");
glColor3f(1.0,1.0,1.0);
drawstring(114,268.0,0.0,"4");
glColor3f(1.0,1.0,1.0);
drawstring(130,268.0,0.0,"5");
glColor3f(1.0,1.0,1.0);
drawstring(147,268.0,0.0,"6");
glColor3f(1.0,1.0,1.0);
drawstring(163,268.0,0.0,"7");
glColor3f(1.0,1.0,1.0);
drawstring(177,268.0,0.0,"0");
glColor3f(1.0,1.0,1.0);
drawstring(305,268.0,0.0,"0");
glColor3f(1.0,1.0,1.0);
drawstring(320,268.0,0.0,"1");
glColor3f(1.0,1.0,1.0);
drawstring(334,268.0,0.0," 2");
glColor3f(1.0,1.0,1.0);
drawstring(349,268.0,0.0," 3");
glColor3f(1.0,1.0,1.0);
drawstring(364,268.0,0.0,"4");
glColor3f(1.0,1.0,1.0);
drawstring(379,268.0,0.0,"5");
glColor3f(1.0,1.0,1.0);
drawstring(394,268.0,0.0,"6");
glColor3f(1.0,1.0,1.0);
drawstring(409,268.0,0.0,"7");
glColor3f(1.0,1.0,1.0);
drawstring(424,268.0,0.0,"0");
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // Send window in WHITE color
glVertex2f(50,255);
glVertex2f(110,255);
glVertex2f(110,290);
glVertex2f(50,290);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0);
slide(10,2,300,260); // Initial set of frames in BLUE color
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // initial sending frames in red
slide(5,2,50,260);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // receiver window in red
slide(5,2,300,260);
glEnd();
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // receiver window in WHITE color
glVertex2f(300,255);
glVertex2f(360,255);
glVertex2f(360,290);
glVertex2f(300,290);
glEnd();
glFlush();
glColor3f(0.0,1.0,0.0); //Frame 0 sent and becoming green
slide(2,2,50,260);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // sliding the window and becoming green
slide(4,2,65,260);
glEnd();
glFlush();
move1(); // movement of data packet
glColor3f(0.0,0.0,1.0); // sliding the window and becoming green
slide(2,2,300,260);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // 4th frame red
slide(2,2,360,260);
glEnd();
glFlush();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP); // To remove initial WHITE window trace
glVertex2f(300,255);
glVertex2f(360,255);
glVertex2f(360,290);
glVertex2f(300,290);
glEnd();
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(315,255);
glVertex2f(375,255);
glVertex2f(375,290);
glVertex2f(315,290);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0); // To remove traces
glBegin(GL_LINES);
glVertex2f(300,260);
glVertex2f(300,285);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // To remove traces
glBegin(GL_LINES);
glVertex2f(360,260);
glVertex2f(360,285);
glEnd();
glFlush();
glColor3f(0.0,1.0,0.0); // sliding the window and becoming green
slide(2,2,65,260);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0); // sliding the window and becoming green
slide(1,2,300,260);
glEnd();
glFlush();
move2();
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0,1.0,1.0);
drawstring(69,268.0,0.0," 1");
glColor3f(1.0,1.0,1.0);
drawstring(320,268.0,0.0,"1");
glColor3f(0.0,0.0,1.0); // sliding the window and becoming blue
slide(2,2,50,260);
glEnd();
glFlush();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP); // To remove initial WHITE window trace
glVertex2f(50,255);
glVertex2f(50,290);
glVertex2f(110,290);
glVertex2f(110,255);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // sliding the window and becoming blue
slide(2,2,110,260);
glBegin(GL_LINES);
glVertex2f(110,260);
glVertex2f(110,285);
glEnd();
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(65,255);
glVertex2f(65,290);
glVertex2f(125,290);
glVertex2f(125,255);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0); //to remove traces
glBegin(GL_LINES);
glVertex2f(50,260);
glVertex2f(50,285);
glEnd();
glFlush();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(315,255);
glVertex2f(375,255);
glVertex2f(375,290);
glVertex2f(315,290);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0);
glBegin(GL_LINES);
glVertex2f(315,260);
glVertex2f(315,285);
glVertex2f(375,260);
glVertex2f(375,285);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0); // sliding the window and becoming green
slide(3,2,300,260);
glEnd();
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(330,255);
glVertex2f(330,290);
glVertex2f(390,290);
glVertex2f(390,255);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // sliding the window and becoming green
slide(2,2,375,260);
glEnd();
glFlush();
move12();
setFont(GLUT_BITMAP_HELVETICA_18);
glColor3f(1.0f,1.0f,1.0f);
drawstring(280.0,163.0,1.0,"ACK 2 lost");
glColor3f(0.0,1.0,1.0); //packet crashing
glBegin(GL_POLYGON);
glVertex2f(240,168);
glVertex2f(255,168);
glVertex2f(260,178);
glVertex2f(265,168);
glVertex2f(280,168);
glVertex2f(267.5,163);
glVertex2f(280,153);
glVertex2f(260,163);
glVertex2f(240,153);
glVertex2f(252.5,163);
glEnd();
glFlush();
glColor3f(0.0,0.0,0.0); //to remove traces
glBegin(GL_TRIANGLES);
glVertex2f(240,168);
glVertex2f(260,178);
glVertex2f(255,168);
glEnd();
glFlush();
glBegin(GL_TRIANGLES);
glVertex2f(240,168);
glVertex2f(252.5,163);
glVertex2f(240,153);
glEnd();
glFlush();
glColor3f(0.0,1.0,0.0); // sliding the window and becoming green
slide(2,2,80,260);
glEnd();
glFlush();
glColor3f(0.0,0.0,0.0);
glBegin(GL_POLYGON); // moving the reciever window in WHITE color
glVertex2f(358,120);
glVertex2f(358,130);
glVertex2f(485,130);
glVertex2f(485,120);
glEnd();
glFlush();
move14();
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0,1.0,1.0);
drawstring(334,268.0,0.0,"2");
setFont(GLUT_BITMAP_HELVETICA_18);
glColor3f(0.0f,0.0f,0.0f);
drawstring(280.0,163.0,1.0,"ACK 2 lost");
glColor3f(0.0,0.0,0.0);
glBegin(GL_POLYGON); // moving the reciever window in WHITE color
glVertex2f(98,100);
glVertex2f(98,112);
glVertex2f(225,112);
glVertex2f(225,100);
glEnd();
glFlush();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(330,255);
glVertex2f(330,290);
glVertex2f(390,290);
glVertex2f(390,255);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0); // sliding the window and becoming green
slide(4,2,300,260);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // sliding the window and becoming green
slide(2,2,390,260);
glEnd();
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(345,255);
glVertex2f(345,290);
glVertex2f(405,290);
glVertex2f(405,255);
glEnd();
glFlush();
glColor3f(0.0,0.0,0.0); //packet crashing
glBegin(GL_POLYGON);
glVertex2f(240,168);
glVertex2f(255,168);
glVertex2f(260,178);
glVertex2f(265,168);
glVertex2f(280,168);
glVertex2f(267.5,163);
glVertex2f(280,153);
glVertex2f(260,163);
glVertex2f(240,153);
glVertex2f(252.5,163);
glEnd();
glFlush();
move13();
setFont(GLUT_BITMAP_HELVETICA_12);
glColor3f(1.0,1.0,1.0);
drawstring(55,268.0,0.0,"0");
glColor3f(1.0,1.0,1.0);
drawstring(69,268.0,0.0," 1");
glColor3f(1.0,1.0,1.0);
drawstring(84,268.0,0.0," 2");
glColor3f(1.0,1.0,1.0);
drawstring(349,268.0,0.0,"3");
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(65,255);
glVertex2f(65,290);
glVertex2f(125,290);
glVertex2f(125,255);
glEnd();
glFlush();
glColor3f(0.0,0.0,1.0); // sliding the window and becoming green
slide(4,2,50,260);
glEnd();
glFlush();
glColor3f(1.0,0.0,0.0); // sliding the window and becoming green
slide(5,2,95,260);
glEnd();
glFlush();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP); // moving the reciever window in WHITE color
glVertex2f(95,255);
glVertex2f(95,290);
glVertex2f(155,290);
glVertex2f(155,255);
glEnd();
glFlush();
}
void output(int x, int y, char *string)
{
int len, i;
glRasterPos2f(x, y);
len = (int) strlen(string);
for (i = 0; i < len; i++) {
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, string[i]);
}
}
void send_options(void) // to draw the text in menu screen
{
glClear(GL_COLOR_BUFFER_BIT);
computers();
//computer1();
//computer2();
//drawop(0,0);
setFont(GLUT_BITMAP_HELVETICA_18);
glColor3f(0.98392,0.49,0.0);
drawstring(180.0,185.0,1.0,"SENDING OPTIONS(select any one)");
glColor3f(1.0,1.0,1.0);
drawstring(67.5,305.0,1.0,"Press A for 1-2");
glFlush();
}
void menuSelect(int value)
{
switch (value)
{
case mainmenu:
text();
break;
case sendop:
send_options();draw6();
break;
case one:
draw3(0,0);
break;
case safesending:
send_options();draw6();
break;
case packetcrashing:
draw4(100,300);delay();draw6();;
break;
case timeout:
draw5(0,300);
break;
}
}
void mykeyboard(unsigned char key,int x,int y)
{
switch(key)
{ case 'e':
case 'E':exit(0); break;
case 's':
case 'S':draw3(0,300);delay();draw6();break;//draw3(); delay();break; //safe sending
case 'p':
case 'P':draw4(0,300);delay();draw6();break; //packet crashing
case 't':
case 'T':draw5(0,300);delay();draw6();break; //time out*/
case 'c':
case 'C':text();break;
default:return;
}
//glutPostRedisplay();
}
void myMouse(int btn, int state, int x, int y)
{
if(btn==GLUT_LEFT_BUTTON && state == GLUT_DOWN )
{int z=1;
x=x/2;
y=(1000-y)/2.1;
printf("%d\t%d\n",x,y);
if((x>=155 && x<=299) && (y>=325 && y<=346 )) // safe sending menu
{
draw3(0,300);delay();draw6();
}
if((x>=155 && x<=299) && (y>=272 && y<=292 )) // packet loss menu
{
draw4(0,300);delay();draw6();
}
if((x>=155 && x<=299) && (y>=221 && y<=241 )) // time outmenu
{
draw5(0,300);delay();draw6();
}
if((x>=155 && x<=299) && (y>=169 && y<=189 )) // exit menu
{
exit(0);
}
if((x>=360 && x<=435) && (y>=82-66 && y<=100-66 ))
{
exit(0);
}
if((x>=360 && x<=435) && (y>=106-66 && y<=122-66 ))
{
text();
}
}
}
void myInit()
{
glClearColor(0.0,0.0,0.0,0.0);
glColor3f(0.0f,0.0f,0.0f);
glPointSize(5.0);
gluOrtho2D(0.0,500.0,0.0,500.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
}
void display(void)
{ glClear(GL_COLOR_BUFFER_BIT);
////////////////////////////
if(flag==0) {text();}
//////////////////////////////////
//delay();
//delay();
//if(flag==0) {text();}
}
void changeSize(int w, int h) {
// Prevent a divide by zero, when window is too short
// (you cant make a window of zero width).
if(h == 0)
h = 1;
float ratio = 1.0* w / h;
// Use the Projection Matrix
glMatrixMode(GL_PROJECTION);
// Reset Matrix
glLoadIdentity();
// Set the viewport to be the entire window
glViewport(0, 0, w, h);
// Set the correct perspective.
gluPerspective(45,ratio,1,1000);
// Get Back to the Modelview
glMatrixMode(GL_MODELVIEW);
}
int main(int argc, char ** argv)
{
int fillmenu = 0;
printf("\nenter a message less than ten characters\n--------------------------------------------\n ");
scanf("%s",E);
printf("%s",E);//printf("--------------------------------------------\n");
if(strlen(E)>10)
{
printf("\nmessage length exceeded......");
//main(0,0);
exit(0);
}
else {
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGBA);
glutInitWindowPosition(0,0);
glutInitWindowSize(1000,1000);
glutReshapeFunc(changeSize);
glutCreateWindow("Selective Repeat ARQ");
glutKeyboardFunc(mykeyboard);
glutMouseFunc(myMouse);
glutDisplayFunc(display);
myInit();
fillmenu = glutCreateMenu(menuSelect);
glutCreateMenu(menuSelect);
//glutAddMenuEntry("Back To Main Menu", mainmenu);
//glutAddSubMenu("safesending", fillmenu);
//glutAddMenuEntry("packetcrashing",packetcrashing );
// glutAddMenuEntry("timeou",timeout);
glutMainLoop();
}
}
|
#include "common.c"
static void dd_signal_handler(int sig) // metodo per la gestione dei segnali
{
if (sig == SIGTERM)
{
exit(EXIT_SUCCESS);
}
if (sig == SIGUSR1)
{
printf("%d è stato ammazzato \n", getpid());
exit(EXIT_SUCCESS);
}
}
int main(int argc, char *argv[])
{
int semID = semget(KEY, 1, 0); // SEMAFORO PARTENZA PROCESSI
if (semID < 0)
{
printf("Errore semaforo partenza processi nel figlio! \n");
}
if (signal(SIGUSR1, dd_signal_handler) == SIG_ERR) // hanlder segnali dal gestore
{
printf("Handler gestore non ha funzionato\n");
exit(0);
}
int memID = shmget(KEY, sizeof(struct type), 0); // ID SHARED MEMORY
int smID = semget(KEY + 1, 1, 0); // SEMAFORO SHARED MEMORY
int mq_AB; // ID coda di messaggi tra le A e i B
int mq_gestore_B; // ID coda di messaggi tra le gestore e i B
// eseguo i vari controlli sugli ID letti dal figlio
if ((mq_AB = msgget(KEY, 0)) < 0)
{ // mi collego alla message queue tra A e B
printf(" [%d] B Errno was set to ==> %s\n", getpid(), strerror(errno));
exit(-1);
}
if ((mq_gestore_B = msgget(KEY + 1, 0)) < 0)
{ // mi collego alla message queue tra B e gestore
printf("[%d] B Errno was set to ==> %s\n", getpid(), strerror(errno));
exit(-1);
}
if (memID < 0)
{
printf("Errore memoria figlio! \n");
}
if (smID < 0)
{
printf("Errore semaforo shared memory figlio \n");
}
int mio_numero = atoi(argv[0]); // Converto il numero del processo da string a int
struct type *b = (struct type *)shmat(memID, NULL, 0); // MI COLLEGO ALLA SHARED MEMORY
//DA QUI IL CODICE DEL FIGLIO
int trovata = 0; // flag per segnalare che ho trovato una A
reserveSem(semID, 0); // attendo che il gestore mi faccia partire
for (;;)
{
pid_t migliore; // PID della A migliore, ovvero quella che sarà contattata
int genoma_migliore = 0; //PID A migliore
int mio_genoma = 0; //genoma A migliore
int num_occupati = 0; //dice quanti processi hanno lo status a 1 quindi non possono morire
int posizione_migliore = 0; // posizione della A che contatterò
//*********SEZIONE CRITICA***************
reserveSem(smID, 0); // prendo il semaforo per l'accesso alla shared memeory
b[mio_numero].status = 1; // metto il mio status a 1 per non essere terminato mentre sono in sezione critica
// con questo for trovo la A migliore tra quelle libere
for (int i = 0; i < INIT_PEOPLE; i++)
{
if (b[i].status == 1) // mi conto
num_occupati++;
if (b[i].tipo == 'A' && b[i].status == 0 && b[i].genoma >= genoma_migliore)
{
migliore = b[i].myPID; // salvo il suo PID
genoma_migliore = b[i].genoma; // e il suo genoma per poterla confrontare con le altre A
posizione_migliore = i;
trovata = 1; //indica di aver trovato una A con le caratteristiche ricercate
}
}
if (num_occupati < (INIT_PEOPLE - 1)) // garantisco che ci siano almeno 2 processi sempre disponibii a morire
{
if (trovata == 1)
{ // Solo se ho trovato una A libera proseguo
b[posizione_migliore].status = 1; //metto lo status della A migliore a 1, entrambi non possiamo piu morire
mio_genoma = b[mio_numero].genoma;
relaseSem(smID, 0); //rilascio l'accesso alla memoria
//**************FINE SEZINE CRITICA**********************
// ho trovato la A migliore e l'ho bloccata, quindi le mando un messaggio
struct messaggioA_B msg1;
msg1.mtype = (long)migliore;
msg1.genoma_mittente = mio_genoma;
msg1.PID_mittente = (int)getpid();
msg1.risposta = 0; // per adesso la risposta è no
if (msgsnd(mq_AB, &msg1, sizeof(msg1), 0) == -1)
{
// MANDO MESSAGGIO
printf("[%d] Invio fallito alla A [%d]. Errno was set to ==> %s\n", getpid(), b[posizione_migliore].myPID, strerror(errno));
}
if ((msgrcv(mq_AB, &msg1, sizeof(msg1), getpid(), 0)) == -1) // RICEVO MESSAGGIO{
printf(" \n******************************** Ricezione fallita dalla A *************************** \n");
if (msg1.risposta == 1) //ho ricevuto una risposta positiva da parte della A ricercata, avviso il gestore
{
struct messaggio_gestore msg_gestore;
msg_gestore.mtype = (int)getppid();
msg_gestore.PID_mittente = (int)getpid();
msg_gestore.PID_partner = (int)migliore;
if (msgsnd(mq_gestore_B, &msg_gestore, sizeof(msg_gestore), 0) == -1) // MANDO MESSAGGIO
printf("Invio fallito al gestore\n");
// Ho trovato una A e avvisato il gestore, la mia vita è finita
printf("[%d] Mi sono accoppiato con %d e ora muoio \n", getpid(), migliore);
for (;;)
{
//ciclo infinito aspettando la SIGTERM del gestore
}
}
else
{
if (msg1.risposta == 0) //la A ha rifiutato il mio contatto, resetto tutti gli status a 0
{
reserveSem(smID, 0); // prendo il semaforo per l'accesso alla shared memeory
b[posizione_migliore].status = 0;
b[mio_numero].status = 0;
b[mio_numero].cont_rifiuti++;
relaseSem(smID, 0); //rilascio l'accesso alla memoria
}
}
}
else
{
b[mio_numero].status = 0;
relaseSem(smID, 0); //rilascio l'accesso alla memoria
}
}
else
{
b[mio_numero].status = 0;
relaseSem(smID, 0); //rilascio l'accesso alla memoria
}
}
}
|
/* 18dec18abu
* (c) Software Lab. Alexander Burger
*/
#include "pico.h"
/* Internal/transient hash */
unsigned long ihash(any x) {
unsigned long g, h;
word n;
for (h = 0; isNum(x); x = cdr(numCell(x)))
for (n = unDig(x); n; n >>= 8)
g = (h = (h<<4) + (n&0xFF)) & 0xF0000000, h = (h ^ g>>24) & ~g;
return h % IHASH;
}
/* External hash */
unsigned long ehash(any x) {
unsigned long h;
word n;
for (h = 0; isNum(x); x = cdr(numCell(x)))
for (n = unDig(x); n; n >>= 11)
h += n;
return h % EHASH;
}
bool hashed(any s, any x) {
while (isCell(x)) {
if (s == car(x))
return YES;
x = cdr(x);
}
return NO;
}
any findHash(any s, any *p) {
any x, y, *q, h;
if (isCell(h = *p)) {
x = s, y = name(car(h));
while (unDig(x) == unDig(y)) {
x = cdr(numCell(x));
y = cdr(numCell(y));
if (!isNum(x) && !isNum(y))
return car(h);
}
while (isCell(h = *(q = &cdr(h)))) {
x = s, y = name(car(h));
while (unDig(x) == unDig(y)) {
x = cdr(numCell(x));
y = cdr(numCell(y));
if (!isNum(x) && !isNum(y)) {
*q = cdr(h), cdr(h) = *p, *p = h;
return car(h);
}
}
}
}
return NULL;
}
void unintern(any s, any *p) {
any x;
while (isCell(x = *p)) {
if (s == car(x)) {
*p = cdr(x);
return;
}
p = &x->cdr;
}
}
/* Get symbol name */
any name(any s) {
for (s = tail1(s); isCell(s); s = cdr(s));
return s;
}
// (name 'sym ['sym2]) -> sym
any doName(any ex) {
any x, y, *p;
unsigned long n;
cell c1;
x = cdr(ex), data(c1) = EVAL(car(x));
NeedSym(ex,data(c1));
y = name(data(c1));
if (!isCell(x = cdr(x)))
return isNum(y)? consStr(y) : Nil;
n = ihash(y);
if (isNil(data(c1)) || isExt(data(c1)) || hashed(data(c1), Intern[n]))
err(ex, data(c1), "Can't rename");
Save(c1);
x = EVAL(car(x));
NeedSym(ex,x);
unintern(data(c1), Transient + n);
for (p = &tail(data(c1)); isCell(*p); p = &cdr(*p));
*p = name(x);
return Pop(c1);
}
/* Find or create single-char symbol */
any mkChar(int c) {
if (c >= 0x80) {
if (c == TOP)
c = 0xFF;
else if (c < 0x800)
c = 0xC0 | c>>6 & 0x1F |
(0x80 | c & 0x3F) << 8;
else if (c < 0x10000)
c = 0xE0 | c>>12 & 0x0F |
(0x80 | c>>6 & 0x3F) << 8 |
(0x80 | c & 0x3F) << 16;
else
c = 0xF0 | c>>18 & 0x07 |
(0x80 | c>>12 & 0x3F) << 8 |
(0x80 | c>>6 & 0x3F) << 16 |
(0x80 | c & 0x3F) << 24;
}
return consStr(box(c));
}
/* Make name */
any mkName(char *s) {
int i;
any nm;
cell c1;
i = 0, Push(c1, nm = box(*(byte*)s++));
while (*s)
byteSym(*(byte*)s++, &i, &nm);
return Pop(c1);
}
any intern(char *s) {
any nm, x, *h;
if (!*s)
return Nil;
nm = mkName(s);
if (x = findHash(nm, h = Intern + ihash(nm)))
return x;
*h = cons(x = consStr(nm), *h);
return x;
}
/* Make string */
any mkStr(char *s) {return s && *s? consStr(mkName(s)) : Nil;}
/* Get first byte of symbol name */
int firstByte(any s) {
return !isNum(s = name(s))? 0 : unDig(s) & 0xFF;
}
int secondByte(any s) {
return !isNum(s = name(s))? 0 : unDig(s) >> 8 & 0xFF;
}
bool isBlank(any x) {
int c;
if (!isSym(x))
return NO;
for (c = symChar(name(x)); c; c = symChar(NULL))
if (c > ' ')
return NO;
return YES;
}
// (sp? 'any) -> flg
any doSpQ(any x) {
x = cdr(x);
return isBlank(EVAL(car(x)))? T : Nil;
}
// (pat? 'any) -> sym | NIL
any doPatQ(any x) {
x = cdr(x);
return isSym(x = EVAL(car(x))) && firstByte(x) == '@'? x : Nil;
}
// (fun? 'any) -> any
any doFunQ(any x) {
x = cdr(x);
return funq(EVAL(car(x)));
}
// (getd 'any) -> fun | NIL
any doGetd(any x) {
x = cdr(x);
if (!isSym(x = EVAL(car(x))))
return Nil;
return !isNil(funq(val(x))) || isNil(val(x)) && sharedLib(x)?
val(x) : Nil;
}
// (all ['T | '0]) -> lst
any doAll(any x) {
any *p;
int mod, i;
cell c1;
x = cdr(x), x = EVAL(car(x));
if isNil(x)
p = Intern, mod = IHASH;
else if (x == T)
p = Transient, mod = IHASH;
else
p = Extern, mod = EHASH;
Push(c1, Nil);
for (i = 0; i < mod; ++i)
for (x = p[i]; isCell(x); x = cdr(x))
data(c1) = cons(car(x), data(c1));
return Pop(c1);
}
// (intern 'sym) -> sym
any doIntern(any ex) {
any x, y, z, *h;
x = cdr(ex), x = EVAL(car(x));
NeedSym(ex,x);
if (!isNum(y = name(x)))
return Nil;
if (unDig(y) == ('L'<<16 | 'I'<<8 | 'N'))
return Nil;
if (z = findHash(y, h = Intern + ihash(y)))
return z;
*h = cons(x,*h);
return x;
}
// (extern 'sym) -> sym | NIL
any doExtern(any ex) {
int c, i;
any x, y, *h, nm;
cell c1, c2;
x = cdr(ex), x = EVAL(car(x));
NeedSym(ex,x);
if (!isNum(x = name(x)))
return Nil;
if (!(y = findHash(x, Extern + ehash(x)))) {
Push(c1, x);
if ((c = symChar(x)) == '{')
c = symChar(NULL);
Push(c2, boxChar(c, &i, &nm));
while ((c = symChar(NULL)) && c != '}')
charSym(c, &i, &nm);
if (!(y = findHash(data(c2), h = Extern + ehash(data(c2))))) {
mkExt(y = consSym(Nil,data(c2)));
*h = cons(y,*h);
}
drop(c1);
}
return isLife(y)? y : Nil;
}
// (==== ['sym ..]) -> NIL
any doHide(any ex) {
any x, y, z, *h;
int i;
for (i = 0; i < IHASH; ++i)
Transient[i] = Nil;
for (x = cdr(ex); isCell(x); x = cdr(x)) {
y = EVAL(car(x));
NeedSym(ex,y);
if (isNum(z = name(y)) && !findHash(z, h = Transient + ihash(z)))
*h = cons(y,*h);
}
return Nil;
}
// (box? 'any) -> sym | NIL
any doBoxQ(any x) {
x = cdr(x);
return isSym(x = EVAL(car(x))) && !isNum(name(x))? x : Nil;
}
// (str? 'any) -> sym | NIL
any doStrQ(any x) {
x = cdr(x);
return isSym(x = EVAL(car(x))) &&
!isExt(x) && !hashed(x, Intern[ihash(name(x))])? x : Nil;
}
// (ext? 'any) -> sym | NIL
any doExtQ(any x) {
x = cdr(x);
return isSym(x = EVAL(car(x))) && isExt(x) && isLife(x) ? x : Nil;
}
// (touch 'sym) -> sym
any doTouch(any ex) {
any x = cdr(ex);
x = EVAL(car(x));
NeedSym(ex,x);
Touch(ex,x);
return x;
}
// (zap 'sym) -> sym
any doZap(any ex) {
any x;
x = cdr(ex), x = EVAL(car(x));
NeedSym(ex,x);
if (isExt(x))
db(ex,x,3);
else {
if (x >= Nil && x <= Bye)
protError(ex,x);
unintern(x, Intern + ihash(name(x)));
}
return x;
}
// (chop 'any) -> lst
any doChop(any x) {
int c;
cell c1, c2;
if (isCell(x = EVAL(cadr(x))))
return x;
if (!(c = symChar(name(x = xSym(x)))))
return Nil;
Push(c1, x);
Push(c2, x = cons(mkChar(c), Nil));
while (c = symChar(NULL))
x = cdr(x) = cons(mkChar(c), Nil);
drop(c1);
return data(c2);
}
void pack(any x, int *i, any *nm, cell *p) {
int c;
cell c1;
if (isCell(x))
do
pack(car(x), i, nm, p);
while (isCell(x = cdr(x)));
if (!isNil(x)) {
if (isNum(x)) {
Push(c1, x = numToSym(x, 0, 0, 0));
c = symChar(name(x));
if (*nm)
charSym(c, i, nm);
else
Tuck(*p, c1, boxChar(c, i, nm));
while (c = symChar(NULL))
charSym(c, i, nm);
drop(c1);
}
else if (c = symChar(name(x))) {
if (*nm) {
if (isExt(x))
charSym('{', i, nm);
charSym(c, i, nm);
}
else if (!isExt(x))
Push(*p, boxChar(c, i, nm));
else {
Push(*p, boxChar('{', i, nm));
charSym(c, i, nm);
}
while (c = symChar(NULL))
charSym(c, i, nm);
if (isExt(x))
charSym('}', i, nm);
}
}
}
// (pack 'any ..) -> sym
any doPack(any x) {
int i;
any nm;
cell c1, c2;
x = cdr(x), Push(c1, EVAL(car(x)));
nm = NULL, pack(data(c1), &i, &nm, &c2);
while (isCell(x = cdr(x)))
pack(data(c1) = EVAL(car(x)), &i, &nm, &c2);
drop(c1);
return nm? consStr(data(c2)) : Nil;
}
// (glue 'any 'lst) -> sym
any doGlue(any x) {
int i;
any nm;
cell c1, c2, c3;
x = cdr(x), Push(c1, EVAL(car(x)));
x = cdr(x), Push(c2, x = EVAL(car(x)));
if (!isCell(x)) {
drop(c1);
return x;
}
nm = NULL, pack(car(x), &i, &nm, &c3);
while (isCell(x = cdr(x))) {
pack(data(c1), &i, &nm, &c3);
pack(car(x), &i, &nm, &c3);
}
drop(c1);
return nm? consStr(data(c3)) : Nil;
}
// (text 'any1 'any ..) -> sym
any doText(any x) {
int c, n, i;
any nm;
any y = evSym(x = cdr(x));
char *p, buf[bufSize(y)];
cell c1;
bufString(y, buf);
if (!*(p = buf))
return Nil;
{
cell arg[length(x = cdr(x))];
for (n = 0; isCell(x); ++n, x = cdr(x))
Push(arg[n], EVAL(car(x)));
nm = NULL;
do {
if ((c = *p++) != '@') {
if (nm)
byteSym(c, &i, &nm);
else
i = 0, Push(c1, nm = box(c & 0xFF));
}
else if (!(c = *p++))
break;
else if (c == '@') {
if (nm)
byteSym('@', &i, &nm);
else
i = 0, Push(c1, nm = box('@'));
}
else if (c >= '1') {
if ((c -= '1') > 8)
c -= 7;
if (n > c)
pack(data(arg[c]), &i, &nm, &c1);
}
} while (*p);
if (n)
drop(arg[0]);
else if (nm)
drop(c1);
return nm? consStr(data(c1)) : Nil;
}
}
static bool pre(word n1, any y, word n2, any x) {
for (;;) {
if ((n1 & 0xFF) != (n2 & 0xFF))
return NO;
if ((n1 >>= 8) == 0) {
if (!isNum(y = cdr(numCell(y))))
return YES;
n1 = unDig(y);
}
if ((n2 >>= 8) == 0) {
if (!isNum(x = cdr(numCell(x))))
return NO;
n2 = unDig(x);
}
}
}
bool subStr(any y, any x) {
word n;
if (!isNum(y = name(y)))
return YES;
if (!isNum(x = name(x)))
return NO;
n = unDig(x);
for (;;) {
if (pre(unDig(y), y, n, x))
return YES;
if ((n >>= 8) == 0) {
if (!isNum(x = cdr(numCell(x))))
return NO;
n = unDig(x);
}
}
}
// (pre? 'any1 'any2) -> any2 | NIL
any doPreQ(any x) {
any y, z;
cell c1;
x = cdr(x), Push(c1, evSym(x));
x = cdr(x), x = evSym(x);
drop(c1);
if (!isNum(y = name(data(c1))))
return x;
if (!isNum(z = name(x)))
return Nil;
return pre(unDig(y), y, unDig(z), z)? x : Nil;
}
// (sub? 'any1 'any2) -> any2 | NIL
any doSubQ(any x) {
cell c1;
x = cdr(x), Push(c1, evSym(x));
x = cdr(x), x = evSym(x);
drop(c1);
return subStr(data(c1), x)? x : Nil;
}
// (val 'var) -> any
any doVal(any ex) {
any x;
x = cdr(ex), x = EVAL(car(x));
NeedVar(ex,x);
if (isSym(x))
Fetch(ex,x);
return val(x);
}
// (set 'var 'any ..) -> any
any doSet(any ex) {
any x;
cell c1, c2;
x = cdr(ex);
do {
Push(c1, EVAL(car(x))), x = cdr(x);
NeedVar(ex,data(c1));
CheckVar(ex,data(c1));
if (isSym(data(c1)))
Touch(ex,data(c1));
Push(c2, EVAL(car(x))), x = cdr(x);
val(data(c1)) = data(c2);
drop(c1);
} while (isCell(x));
return val(data(c1));
}
// (setq var 'any ..) -> any
any doSetq(any ex) {
any x, y;
x = cdr(ex);
do {
y = car(x), x = cdr(x);
NeedVar(ex,y);
CheckVar(ex,y);
val(y) = EVAL(car(x));
} while (isCell(x = cdr(x)));
return val(y);
}
// (swap 'var 'any) -> any
any doSwap(any ex) {
any x, y;
cell c1;
x = cdr(ex), Push(c1, EVAL(car(x)));
NeedVar(ex,data(c1));
CheckVar(ex,data(c1));
if (isSym(data(c1)))
Touch(ex,data(c1));
y = val(data(c1));
x = cdr(x), val(data(c1)) = EVAL(car(x));
drop(c1);
return y;
}
// (xchg 'var 'var ..) -> any
any doXchg(any ex) {
any x, y;
cell c1, c2;
x = cdr(ex);
do {
Push(c1, EVAL(car(x))), x = cdr(x);
NeedVar(ex,data(c1));
CheckVar(ex,data(c1));
if (isSym(data(c1)))
Touch(ex,data(c1));
Push(c2, EVAL(car(x))), x = cdr(x);
NeedVar(ex,data(c2));
CheckVar(ex,data(c2));
if (isSym(data(c2)))
Touch(ex,data(c2));
y = val(data(c1)), val(data(c1)) = val(data(c2)), val(data(c2)) = y;
drop(c1);
} while (isCell(x));
return y;
}
// (on var ..) -> T
any doOn(any ex) {
any x = cdr(ex);
do {
NeedVar(ex,car(x));
CheckVar(ex,car(x));
val(car(x)) = T;
} while (isCell(x = cdr(x)));
return T;
}
// (off var ..) -> NIL
any doOff(any ex) {
any x = cdr(ex);
do {
NeedVar(ex,car(x));
CheckVar(ex,car(x));
val(car(x)) = Nil;
} while (isCell(x = cdr(x)));
return Nil;
}
// (onOff var ..) -> flg
any doOnOff(any ex) {
any x = cdr(ex);
any y;
do {
NeedVar(ex,car(x));
CheckVar(ex,car(x));
y = val(car(x)) = isNil(val(car(x)))? T : Nil;
} while (isCell(x = cdr(x)));
return y;
}
// (zero var ..) -> 0
any doZero(any ex) {
any x = cdr(ex);
do {
NeedVar(ex,car(x));
CheckVar(ex,car(x));
val(car(x)) = Zero;
} while (isCell(x = cdr(x)));
return Zero;
}
// (one var ..) -> 1
any doOne(any ex) {
any x = cdr(ex);
do {
NeedVar(ex,car(x));
CheckVar(ex,car(x));
val(car(x)) = One;
} while (isCell(x = cdr(x)));
return One;
}
// (default var 'any ..) -> any
any doDefault(any ex) {
any x, y;
x = cdr(ex);
do {
y = car(x), x = cdr(x);
NeedVar(ex,y);
CheckVar(ex,y);
if (isNil(val(y)))
val(y) = EVAL(car(x));
} while (isCell(x = cdr(x)));
return val(y);
}
// (push 'var 'any ..) -> any
any doPush(any ex) {
any x;
cell c1, c2;
x = cdr(ex), Push(c1, EVAL(car(x)));
NeedVar(ex,data(c1));
CheckVar(ex,data(c1));
if (isSym(data(c1)))
Touch(ex,data(c1));
x = cdr(x), Push(c2, EVAL(car(x)));
val(data(c1)) = cons(data(c2), val(data(c1)));
while (isCell(x = cdr(x))) {
data(c2) = EVAL(car(x));
val(data(c1)) = cons(data(c2), val(data(c1)));
}
drop(c1);
return data(c2);
}
// (push1 'var 'any ..) -> any
any doPush1(any ex) {
any x;
cell c1, c2;
x = cdr(ex), Push(c1, EVAL(car(x)));
NeedVar(ex,data(c1));
CheckVar(ex,data(c1));
if (isSym(data(c1)))
Touch(ex,data(c1));
x = cdr(x), Push(c2, EVAL(car(x)));
if (!member(data(c2), val(data(c1))))
val(data(c1)) = cons(data(c2), val(data(c1)));
while (isCell(x = cdr(x)))
if (!member(data(c2) = EVAL(car(x)), val(data(c1))))
val(data(c1)) = cons(data(c2), val(data(c1)));
drop(c1);
return data(c2);
}
// (push1q 'var 'any ..) -> any
any doPush1q(any ex) {
any x;
cell c1, c2;
x = cdr(ex), Push(c1, EVAL(car(x)));
NeedVar(ex,data(c1));
CheckVar(ex,data(c1));
if (isSym(data(c1)))
Touch(ex,data(c1));
x = cdr(x), Push(c2, EVAL(car(x)));
if (!memq(data(c2), val(data(c1))))
val(data(c1)) = cons(data(c2), val(data(c1)));
while (isCell(x = cdr(x)))
if (!memq(data(c2) = EVAL(car(x)), val(data(c1))))
val(data(c1)) = cons(data(c2), val(data(c1)));
drop(c1);
return data(c2);
}
// (pop 'var) -> any
any doPop(any ex) {
any x, y;
x = cdr(ex), x = EVAL(car(x));
NeedVar(ex,x);
CheckVar(ex,x);
if (isSym(x))
Touch(ex,x);
if (!isCell(y = val(x)))
return y;
val(x) = cdr(y);
return car(y);
}
// (++ var) -> any
any doPopq(any ex) {
any x, y;
x = cadr(ex);
NeedVar(ex,x);
CheckVar(ex,x);
if (!isCell(y = val(x)))
return y;
val(x) = cdr(y);
return car(y);
}
// (cut 'cnt 'var) -> lst
any doCut(any ex) {
long n;
any x, y;
cell c1, c2;
if ((n = evCnt(ex, x = cdr(ex))) <= 0)
return Nil;
x = cdr(x), Push(c1, EVAL(car(x)));
NeedVar(ex,data(c1));
CheckVar(ex,data(c1));
if (isSym(data(c1)))
Touch(ex,data(c1));
if (isCell(val(data(c1)))) {
Push(c2, y = cons(car(val(data(c1))), Nil));
while (isCell(val(data(c1)) = cdr(val(data(c1)))) && --n)
y = cdr(y) = cons(car(val(data(c1))), Nil);
drop(c1);
return data(c2);
}
return val(Pop(c1));
}
// (del 'any 'var ['flg]) -> lst
any doDel(any ex) {
any x, y;
bool flg;
cell c1, c2, c3;
x = cdr(ex), Push(c1, EVAL(car(x)));
x = cadr(x), Push(c2, EVAL(x));
flg = !isNil(EVAL(cadddr(ex)));
NeedVar(ex,data(c2));
CheckVar(ex,data(c2));
if (isSym(data(c2)))
Touch(ex,data(c2));
x = val(data(c2));
for (;;) {
if (!isCell(x)) {
drop(c1);
return x;
}
if (!equal(data(c1), car(x)))
break;
val(data(c2)) = x = cdr(x);
if (!flg) {
drop(c1);
return x;
}
}
Push(c3, y = cons(car(x), Nil));
while (isCell(x = cdr(x))) {
if (equal(data(c1), car(x))) {
if (flg)
continue;
cdr(y) = cdr(x);
drop(c1);
return val(data(c2)) = data(c3);
}
y = cdr(y) = cons(car(x), Nil);
}
cdr(y) = x;
drop(c1);
return val(data(c2)) = data(c3);
}
// (queue 'var 'any) -> any
any doQueue(any ex) {
any x, y;
cell c1;
x = cdr(ex), Push(c1, EVAL(car(x)));
NeedVar(ex,data(c1));
CheckVar(ex,data(c1));
if (isSym(data(c1)))
Touch(ex,data(c1));
x = cdr(x), x = EVAL(car(x));
if (!isCell(y = val(data(c1))))
val(data(c1)) = cons(x,Nil);
else {
while (isCell(cdr(y)))
y = cdr(y);
cdr(y) = cons(x,Nil);
}
drop(c1);
return x;
}
// (fifo 'var ['any ..]) -> any
any doFifo(any ex) {
any x, y, z;
cell c1;
x = cdr(ex), Push(c1, EVAL(car(x)));
NeedVar(ex,data(c1));
CheckVar(ex,data(c1));
if (isSym(data(c1)))
Touch(ex,data(c1));
if (isCell(x = cdr(x))) {
y = EVAL(car(x));
if (isCell(z = val(data(c1))))
val(data(c1)) = z = cdr(z) = cons(y,cdr(z));
else {
z = val(data(c1)) = cons(y,Nil);
cdr(z) = z;
}
while (isCell(x = cdr(x)))
val(data(c1)) = z = cdr(z) = cons(y = EVAL(car(x)), cdr(z));
}
else if (!isCell(z = val(data(c1))))
y = Nil;
else {
if (z == cdr(z)) {
y = car(z);
val(data(c1)) = Nil;
}
else {
y = cadr(z);
cdr(z) = cddr(z);
}
}
drop(c1);
return y;
}
any idx(any var, any key, int flg) {
any x, y, z, *p;
int n;
if (!key) {
cell c1, c2;
if (!isCell(x = val(var)))
return Nil;
y = Nil; // Result
Push(c1, x); // Tree
Push(c2, Nil); // TOS
for (;;) {
while (isCell(cddr(data(c1))))
z = data(c1), data(c1) = cddr(z), cddr(z) = data(c2), data(c2) = z;
for (;;) {
y = cons(car(data(c1)), y);
if (isCell(cadr(data(c1)))) {
z = data(c1), data(c1) = cadr(z), cadr(z) = data(c2), data(c2) = symPtr(z);
break;
}
for (;;) {
if (isNil(data(c2))) {
drop(c1);
return y;
}
if (isCell(data(c2))) {
z = data(c2), data(c2) = cddr(z), cddr(z) = data(c1), data(c1) = z;
break;
}
z = cellPtr(data(c2)), data(c2) = cadr(z), cadr(z) = data(c1), data(c1) = z;
}
}
}
}
if (!isCell(x = val(var))) {
if (flg > 0)
val(var) = cons(key,Nil);
return Nil;
}
p = (any*)var;
for (;;) {
if ((n = compare(key, car(x))) == 0) {
if (flg < 0) {
if (!isCell(cadr(x)))
*p = cddr(x);
else if (!isCell(y = cddr(x)))
*p = cadr(x);
else if (!isCell(z = cadr(y)))
car(x) = car(y), cddr(x) = cddr(y);
else {
while (isCell(cadr(z)))
z = cadr(y = z);
car(x) = car(z), cadr(y) = cddr(z);
}
}
return x;
}
if (!isCell(cdr(x))) {
if (flg > 0)
cdr(x) = n < 0? cons(cons(key,Nil), Nil) : cons(Nil, cons(key,Nil));
return Nil;
}
if (n < 0) {
if (!isCell(cadr(x))) {
if (flg > 0)
cadr(x) = cons(key,Nil);
return Nil;
}
x = *(p = &cadr(x));
}
else {
if (!isCell(cddr(x))) {
if (flg > 0)
cddr(x) = cons(key,Nil);
return Nil;
}
x = *(p = &cddr(x));
}
}
}
// (idx 'var 'any 'flg) -> lst
// (idx 'var 'any) -> lst
// (idx 'var) -> lst
any doIdx(any ex) {
any x;
int flg;
cell c1, c2;
x = cdr(ex), Push(c1, EVAL(car(x)));
NeedVar(ex,data(c1));
CheckVar(ex,data(c1));
if (!isCell(x = cdr(x)))
x = idx(data(c1), NULL, 0);
else {
Push(c2, EVAL(car(x)));
if (!isCell(cdr(x)))
flg = 0;
else
flg = isNil(EVAL(cadr(x)))? -1 : +1;
x = idx(data(c1), data(c2), flg);
}
drop(c1);
return x;
}
// (lup 'lst 'any) -> lst
// (lup 'lst 'any 'any2) -> lst
any doLup(any x) {
int n;
cell c1, c2, c3, c4, c5;
x = cdr(x), data(c1) = EVAL(car(x));
if (!isCell(data(c1)))
return data(c1);
Save(c1);
x = cdr(x), Push(c2, EVAL(car(x))); // from
if (isCell(x = cdr(x))) {
Push(c3, EVAL(car(x))); // to
Push(c4, Nil); // tos
Push(c5, Nil); // result
for (;;) {
while (isCell(cddr(data(c1))) && car(data(c1)) != T && (!isCell(car(data(c1))) || compare(data(c3), caar(data(c1))) >= 0))
x = data(c1), data(c1) = cddr(x), cddr(x) = data(c4), data(c4) = x;
for (;;) {
if (isCell(car(data(c1))) && compare(data(c2), caar(data(c1))) <= 0) {
if (compare(data(c3), caar(data(c1))) >= 0)
data(c5) = cons(car(data(c1)), data(c5));
if (isCell(cadr(data(c1)))) {
x = data(c1), data(c1) = cadr(x), cadr(x) = data(c4), data(c4) = symPtr(x);
break;
}
}
for (;;) {
if (isNil(data(c4))) {
drop(c1);
return data(c5);
}
if (isCell(data(c4))) {
x = data(c4), data(c4) = cddr(x), cddr(x) = data(c1), data(c1) = x;
break;
}
else
x = cellPtr(data(c4)), data(c4) = cadr(x), cadr(x) = data(c1), data(c1) = x;
}
}
}
}
do {
if (car(data(c1)) == T)
data(c1) = cadr(data(c1));
else if (!isCell(car(data(c1))))
data(c1) = cddr(data(c1));
else if (n = compare(data(c2), caar(data(c1))))
data(c1) = n < 0? cadr(data(c1)) : cddr(data(c1));
else {
drop(c1);
return car(data(c1));
}
} while (isCell(data(c1)));
drop(c1);
return Nil;
}
void put(any x, any key, any val) {
any y, z;
if (isCell(y = tail1(x))) {
if (isCell(car(y))) {
if (key == cdar(y)) {
if (isNil(val))
Tail(x, cdr(y));
else if (val == T)
car(y) = key;
else
caar(y) = val;
return;
}
}
else if (key == car(y)) {
if (isNil(val))
Tail(x, cdr(y));
else if (val != T)
car(y) = cons(val,key);
return;
}
while (isCell(z = cdr(y))) {
if (isCell(car(z))) {
if (key == cdar(z)) {
if (isNil(val))
cdr(y) = cdr(z);
else {
if (val == T)
car(z) = key;
else
caar(z) = val;
cdr(y) = cdr(z), cdr(z) = tail1(x), Tail(x, z);
}
return;
}
}
else if (key == car(z)) {
if (isNil(val))
cdr(y) = cdr(z);
else {
if (val != T)
car(z) = cons(val,key);
cdr(y) = cdr(z), cdr(z) = tail1(x), Tail(x, z);
}
return;
}
y = z;
}
}
if (!isNil(val))
Tail(x, cons(val==T? key : cons(val,key), tail1(x)));
}
any get(any x, any key) {
any y, z;
if (!isCell(y = tail1(x)))
return Nil;
if (!isCell(car(y))) {
if (key == car(y))
return T;
}
else if (key == cdar(y))
return caar(y);
while (isCell(z = cdr(y))) {
if (!isCell(car(z))) {
if (key == car(z)) {
cdr(y) = cdr(z), cdr(z) = tail1(x), Tail(x, z);
return T;
}
}
else if (key == cdar(z)) {
cdr(y) = cdr(z), cdr(z) = tail1(x), Tail(x, z);
return caar(z);
}
y = z;
}
return Nil;
}
any prop(any x, any key) {
any y, z;
if (isCell(y = tail1(x))) {
if (!isCell(car(y))) {
if (key == car(y))
return key;
}
else if (key == cdar(y))
return car(y);
while (isCell(z = cdr(y))) {
if (!isCell(car(z))) {
if (key == car(z)) {
cdr(y) = cdr(z), cdr(z) = tail1(x), Tail(x, z);
return key;
}
}
else if (key == cdar(z)) {
cdr(y) = cdr(z), cdr(z) = tail1(x), Tail(x, z);
return car(z);
}
y = z;
}
}
Tail(x, cons(y = cons(Nil,key), tail1(x)));
return y;
}
// (put 'sym1|lst ['sym2|cnt ..] 'sym|0 'any) -> any
any doPut(any ex) {
any x;
cell c1, c2, c3;
x = cdr(ex), Push(c1, EVAL(car(x)));
x = cdr(x), Push(c2, EVAL(car(x)));
while (isCell(cdr(x = cdr(x)))) {
if (isCell(data(c1)))
data(c1) = getn(data(c2), data(c1));
else {
NeedSym(ex,data(c1));
Fetch(ex,data(c1));
data(c1) = isNum(data(c2)) && !unDig(data(c2))? val(data(c1)) : get(data(c1), data(c2));
}
data(c2) = EVAL(car(x));
}
NeedSym(ex,data(c1));
Push(c3, EVAL(car(x)));
if (isNum(data(c2)) && IsZero(data(c2))) {
Touch(ex,data(c1));
CheckVar(ex,data(c1));
val(data(c1)) = x = data(c3);
}
else {
if (isExt(data(c1)))
db(ex, data(c1), !isNil(data(c2))? 2 : 1);
put(data(c1), data(c2), x = data(c3));
}
drop(c1);
return x;
}
// (get 'sym1|lst ['sym2|cnt ..]) -> any
any doGet(any ex) {
any x, y;
cell c1;
x = cdr(ex), data(c1) = EVAL(car(x));
if (!isCell(x = cdr(x)))
return data(c1);
Save(c1);
do {
y = EVAL(car(x));
if (isCell(data(c1)))
data(c1) = getn(y, data(c1));
else {
NeedSym(ex,data(c1));
Fetch(ex,data(c1));
data(c1) = isNum(y) && !unDig(y)? val(data(c1)) : get(data(c1), y);
}
} while (isCell(x = cdr(x)));
return Pop(c1);
}
// (prop 'sym1|lst ['sym2|cnt ..] 'sym) -> var
any doProp(any ex) {
any x;
cell c1, c2;
x = cdr(ex), Push(c1, EVAL(car(x)));
x = cdr(x), Push(c2, EVAL(car(x)));
while (isCell(x = cdr(x))) {
if (isCell(data(c1)))
data(c1) = getn(data(c2), data(c1));
else {
NeedSym(ex,data(c1));
Fetch(ex,data(c1));
data(c1) = isNum(data(c2)) && !unDig(data(c2))? val(data(c1)) : get(data(c1), data(c2));
}
data(c2) = EVAL(car(x));
}
NeedSym(ex,data(c1));
CheckNil(ex,data(c1));
if (isExt(data(c1)))
db(ex, data(c1), !isNil(data(c2))? 2 : 1);
return prop(Pop(c1), data(c2));
}
// (; 'sym1|lst [sym2|cnt ..]) -> any
any doSemicol(any ex) {
any x;
cell c1;
x = cdr(ex), data(c1) = EVAL(car(x));
if (!isCell(x = cdr(x)))
return data(c1);
Save(c1);
do {
if (isCell(data(c1)))
data(c1) = getn(car(x), data(c1));
else {
NeedSym(ex,data(c1));
Fetch(ex,data(c1));
data(c1) = isNum(car(x)) && !unDig(car(x))? val(data(c1)) : get(data(c1), car(x));
}
} while (isCell(x = cdr(x)));
return Pop(c1);
}
// (=: sym|0 [sym1|cnt .. sym2|0] 'any) -> any
any doSetCol(any ex) {
any x, y, z;
cell c1;
x = cdr(ex), y = val(This);
if (z = car(x), isCell(cdr(x = cdr(x)))) {
Fetch(ex,y);
y = isNum(z) && !unDig(z)? val(y) : get(y,z);
while (z = car(x), isCell(cdr(x = cdr(x)))) {
if (isCell(y))
y = getn(z,y);
else {
NeedSym(ex,y);
Fetch(ex,y);
y = isNum(z) && !unDig(z)? val(y) : get(y,z);
}
}
}
NeedSym(ex,y);
Push(c1, EVAL(car(x)));
if (isNum(z) && IsZero(z)) {
Touch(ex,y);
CheckVar(ex,y);
val(y) = x = data(c1);
}
else {
if (isExt(y))
db(ex, y, !isNil(z)? 2 : 1);
put(y, z, x = data(c1));
}
drop(c1);
return x;
}
// (: sym|0 [sym1|cnt ..]) -> any
any doCol(any ex) {
any x, y;
x = cdr(ex), y = val(This);
Fetch(ex,y);
y = isNum(car(x)) && !unDig(car(x))? val(y) : get(y, car(x));
while (isCell(x = cdr(x))) {
if (isCell(y))
y = getn(car(x), y);
else {
NeedSym(ex,y);
Fetch(ex,y);
y = isNum(car(x)) && !unDig(car(x))? val(y) : get(y, car(x));
}
}
return y;
}
// (:: sym|0 [sym1|cnt .. sym2]) -> var
any doPropCol(any ex) {
any x, y;
x = cdr(ex), y = val(This);
if (isCell(cdr(x))) {
Fetch(ex,y);
y = isNum(car(x)) && !unDig(car(x))? val(y) : get(y, car(x));
while (isCell(cdr(x = cdr(x)))) {
if (isCell(y))
y = getn(car(x), y);
else {
NeedSym(ex,y);
Fetch(ex,y);
y = isNum(car(x)) && !unDig(car(x))? val(y) : get(y, car(x));
}
}
}
NeedSym(ex,y);
CheckNil(ex,y);
if (isExt(y))
db(ex, y, !isNil(car(x))? 2 : 1);
return prop(y, car(x));
}
// (putl 'sym1|lst1 ['sym2|cnt ..] 'lst) -> lst
any doPutl(any ex) {
any x;
cell c1, c2;
x = cdr(ex), Push(c1, EVAL(car(x)));
x = cdr(x), Push(c2, EVAL(car(x)));
while (isCell(x = cdr(x))) {
if (isCell(data(c1)))
data(c1) = getn(data(c2), data(c1));
else {
NeedSym(ex,data(c1));
Fetch(ex,data(c1));
data(c1) = isNum(data(c2)) && !unDig(data(c2))? val(data(c1)) : get(data(c1), data(c2));
}
data(c2) = EVAL(car(x));
}
NeedSym(ex,data(c1));
CheckNil(ex,data(c1));
Touch(ex,data(c1));
while (isCell(tail(data(c1))))
Tail(data(c1), cdr(tail1(data(c1))));
for (x = data(c2); isCell(x); x = cdr(x)) {
if (!isCell(car(x)))
Tail(data(c1), cons(car(x), tail1(data(c1))));
else if (!isNil(caar(x)))
Tail(data(c1), cons(caar(x)==T? cdar(x) : car(x), tail1(data(c1))));
}
drop(c1);
return data(c2);
}
// (getl 'sym1|lst1 ['sym2|cnt ..]) -> lst
any doGetl(any ex) {
any x, y;
cell c1, c2;
x = cdr(ex), Push(c1, EVAL(car(x)));
while (isCell(x = cdr(x))) {
y = EVAL(car(x));
if (isCell(data(c1)))
data(c1) = getn(y, data(c1));
else {
NeedSym(ex,data(c1));
Fetch(ex,data(c1));
data(c1) = isNum(y) && !unDig(y)? val(data(c1)) : get(data(c1), y);
}
}
NeedSym(ex,data(c1));
Fetch(ex,data(c1));
if (!isCell(x = tail1(data(c1))))
data(c2) = Nil;
else {
Push(c2, y = cons(car(x),Nil));
while (isCell(x = cdr(x)))
y = cdr(y) = cons(car(x),Nil);
}
drop(c1);
return data(c2);
}
static void wipe(any ex, any x) {
any y, z;
NeedSym(ex,x);
CheckVar(ex,x);
for (y = tail1(x); isCell(y); y = cdr(y));
if (!isNum(y)) {
val(x) = Nil;
tail(x) = y;
}
else {
z = numCell(y);
while (isNum(cdr(z)))
z = numCell(cdr(z));
if (isNil(cdr(z)) || cdr(z) == At) {
val(x) = Nil;
Tail(x, y);
cdr(z) = Nil;
}
}
}
// (wipe 'sym|lst) -> sym|lst
any doWipe(any ex) {
any x, y;
x = cdr(ex);
if (!isNil(x = EVAL(car(x))))
if (!isCell(x))
wipe(ex, x);
else {
y = x; do
wipe(ex, car(y));
while (isCell(y = cdr(y)));
}
return x;
}
static any meta(any x, any y) {
any z;
while (isCell(x)) {
if (isSym(car(x)))
if (!isNil(z = get(car(x),y)) || !isNil(z = meta(val(car(x)), y)))
return z;
x = cdr(x);
}
return Nil;
}
// (meta 'obj|typ 'sym ['sym2|cnt ..]) -> any
any doMeta(any ex) {
any x, y;
cell c1;
x = cdr(ex), Push(c1, EVAL(car(x)));
if (isSym(data(c1))) {
Fetch(ex,data(c1));
data(c1) = val(data(c1));
}
x = cdr(x), y = EVAL(car(x));
data(c1) = meta(data(c1), y);
while (isCell(x = cdr(x))) {
y = EVAL(car(x));
if (isCell(data(c1)))
data(c1) = getn(y, data(c1));
else {
NeedSym(ex,data(c1));
Fetch(ex,data(c1));
data(c1) = isNum(y) && !unDig(y)? val(data(c1)) : get(data(c1), y);
}
}
return Pop(c1);
}
/*** Case mappings from the GNU Kaffe Project ***/
#define CHAR_UPPERCASE 1
#define CHAR_LOWERCASE 2
#define CHAR_LETTER 62
#define CHAR_DIGIT 512
static uint16_t Blocks[] = {
0x1C2, 0x1C2, 0x1C1, 0x12C, 0x12B, 0x1A0, 0x1F8, 0x2DC, 0x25F, 0x2EE, 0x215, 0x346, 0x2DC, 0x326, 0x2BC, 0x216,
0x15F, 0x2D4, 0x376, 0x376, 0x376, 0x369, 0xFE8F, 0x344, 0xFF85, 0xFF65, 0xFDB5, 0xFDA1, 0x1B, 0x2C4, 0x1C, 0x47,
0xFEA8, 0xFF8C, 0x235, 0xFEFF, 0x1A, 0xFEBF, 0x26, 0xFB20, 0xFE28, 0x113, 0x104, 0xFB61, 0xFB5A, 0x10B, 0x109, 0xFE,
0xFF08, 0x229, 0x25E, 0x1C7, 0x1FC, 0x1DC, 0xFC46, 0x229, 0xFE27, 0xFB55, 0x169, 0xFBC8, 0xFC, 0x103, 0xFB68, 0xFB48,
0xFB28, 0xFB08, 0xFAE8, 0xFAC8, 0xFAA8, 0xFA88, 0xFA68, 0xFA48, 0x65, 0x50, 0xAB, 0x139, 0xFE0E, 0x63, 0x155, 0x1A8,
0xF669, 0x129, 0x128, 0xF91F, 0xFE56, 0x108, 0x107, 0xFAC0, 0xFC8E, 0xFEAD, 0xC6, 0xFCA7, 0xFB95, 0xF47D, 0x9F, 0xFB17,
0xFE20, 0xFD28, 0xFB2F, 0x3B, 0xF3B9, 0xFE57, 0xFCCE, 0xFFBB, 0xF339, 0xFA98, 0xFF8B, 0xFF3B, 0xFA54, 0xF7E3, 0xFF2B, 0xFAD7,
0xFB69, 0xFC3A, 0xFEE5, 0xF4C8, 0xFCB0, 0xFA88, 0xFDBF, 0xF448, 0xFE45, 0xFCC7, 0xFE4F, 0xF7F1, 0xF715, 0xF2E8, 0xFD9F, 0xF348,
0xF96A, 0xFC02, 0xFD97, 0xF2C8, 0xF2A8, 0xF4B9, 0xF4B3, 0xEF6B, 0xF86A, 0xF84A, 0xFC58, 0xF80A, 0xF7EA, 0xFC0F, 0xF7AA, 0xEE9C,
0xFB90, 0xF74A, 0xF7FA, 0xF70A, 0xF7CA, 0xF792, 0xF471, 0xF4D2, 0xF732, 0xF64A, 0xF401, 0xF64D, 0xEFA8, 0xF5CA, 0xF5AA, 0xECA1,
0xF569, 0xF54A, 0xF52A, 0xF50A, 0xF4EA, 0xF4CA, 0xF4AA, 0xF48A, 0xF46A, 0xF44A, 0xF42A, 0xF40A, 0xF3EA, 0xF3CA, 0xF3AA, 0xF38A,
0xF36A, 0xF34A, 0xF32A, 0xF289, 0xF777, 0xF2CA, 0xF2AA, 0xF737, 0xEC28, 0xEC08, 0xEBE8, 0xEBC8, 0xF1EA, 0xF4A2, 0xF545, 0xEDC6,
0xF2D7, 0xF14A, 0xE8ED, 0xE81E, 0xF0EA, 0xF597, 0xEA68, 0xEA48, 0xEA28, 0xEA08, 0xE9E8, 0xE9C8, 0xE9A8, 0xE988, 0xE968, 0xE948,
0xE928, 0xE908, 0xE8E8, 0xE8C8, 0xE8A8, 0xE888, 0xE868, 0xE848, 0xE828, 0xE808, 0xE7E8, 0xE7C8, 0xE7A8, 0xE788, 0xE768, 0xE748,
0xE728, 0xE708, 0xE6E8, 0xE6C8, 0xE6A8, 0xE688, 0xE668, 0xE648, 0xE628, 0xE608, 0xE5E8, 0xE5C8, 0xE5A8, 0xE588, 0xE568, 0xE548,
0xE55F, 0xE53F, 0xE51F, 0xE4FF, 0xEFD7, 0xE4BF, 0xE49F, 0xE485, 0xEF87, 0xEF57, 0xEF57, 0xEF57, 0xEF57, 0xEF47, 0xE1AD, 0xEF46,
0xEF46, 0xEF46, 0xE1E0, 0xE3DD, 0xEF06, 0xE9D9, 0xEBEB, 0xE244, 0xEED4, 0xEF65, 0xE1F5, 0xEF45, 0xEEE9, 0xEF7C, 0xEE74, 0xEF70,
0xEF7D, 0xEF78, 0xEE91, 0xEFD3, 0xEE7D, 0xEE25, 0xEE27, 0xEF65, 0xEFDD, 0xEE96, 0xEFD3, 0xEFE1, 0xEF69, 0xDF88, 0xDF68, 0xDF48,
0xED2B, 0xED3D, 0xED19, 0xEF1C, 0xEF08, 0xED47, 0xED3D, 0xED33, 0xEC2B, 0xEC0B, 0xEBEB, 0xEBCB, 0xEBCE, 0xEA7C, 0xEB69, 0xEB6C,
0xE9B6, 0xEB0B, 0xEAEB, 0xE9E9, 0xDCA8, 0xDC88, 0xDC68, 0xDC48, 0xE910, 0xEA23, 0xEB58, 0xEB4F, 0xEB45, 0xEAE5, 0xDB68, 0xDB48,
0xE92B, 0xE90B, 0xE8EB, 0xE8CB, 0xE8AB, 0xE88B, 0xE86B, 0xE84B, 0xDA28, 0xDA08, 0xD9E8, 0xD9C8, 0xD9A8, 0xD988, 0xD968, 0xD948,
0xD928, 0xD908, 0xD8E8, 0xD8C8, 0xD8A8, 0xD888, 0xD868, 0xD848, 0xD828, 0xD808, 0xD7E8, 0xD7C8, 0xD7A8, 0xD788, 0xD768, 0xD748,
0xD728, 0xD708, 0xD6E8, 0xD6C8, 0xD6A8, 0xD688, 0xD668, 0xD648, 0xD628, 0xD608, 0xD5E8, 0xD5C8, 0xD5A8, 0xD588, 0xD568, 0xD548,
0xD528, 0xD508, 0xD4E8, 0xD4C8, 0xE2B1, 0xE28B, 0xE26B, 0xE270, 0xE22B, 0xE20B, 0xE1EB, 0xE1CB, 0xE1AB, 0xE18B, 0xE18E, 0xDD8F,
0xE3A8, 0xDFD3, 0xD929, 0xD90A, 0xE348, 0xD8C9, 0xD8AA, 0xDCD7, 0xDCB2, 0xD681, 0xD82A, 0xD80A, 0xE268, 0xCEDE, 0xD168, 0xD148,
0xE116, 0xE0E9, 0xE1CB, 0xE0B7, 0xE0B7, 0xE15E, 0xDF17, 0xE034, 0xE013, 0xDFF3, 0xDFD3, 0xDE6C, 0xDF93, 0xDF73, 0xDF55, 0xDF34,
0xD56A, 0xD54A, 0xD52A, 0xD50A, 0xD4EA, 0xD4CA, 0xD4AA, 0xD48A, 0xD46A, 0xD44A, 0xD42A, 0xD40A, 0xD3EA, 0xD3CA, 0xD3AA, 0xD38A,
0xD36A, 0xD34A, 0xD32A, 0xD30A, 0xD2EA, 0xD2CA, 0xD2AA, 0xD28A, 0xD26A, 0xD24A, 0xD22A, 0xD20A, 0xD1EA, 0xD1CA, 0xD1AA, 0xD18A,
0xD16A, 0xD14A, 0xD12A, 0xD10A, 0xD0EA, 0xD0CA, 0xD0AA, 0xD08A, 0xD06A, 0xD04A, 0xD02A, 0xD00A, 0xCFEA, 0xCFCA, 0xCFAA, 0xCF8A,
0xCF6A, 0xCF4A, 0xCF2A, 0xCF0A, 0xCEEA, 0xCECA, 0xCEAA, 0xCE8A, 0xCE6A, 0xCE4A, 0xCE2A, 0xCE0A, 0xCDEA, 0xCDCA, 0xCDAA, 0xCD8A,
0xCD6A, 0xCD4A, 0xCD2A, 0xCD0A, 0xCCEA, 0xCCCA, 0xCCAA, 0xCC8A, 0xCC6A, 0xCC4A, 0xCC2A, 0xCC0A, 0xCBEA, 0xCBCA, 0xCBAA, 0xCB8A,
0xCB6A, 0xCB4A, 0xCB2A, 0xCB0A, 0xCAEA, 0xCACA, 0xCAAA, 0xCA8A, 0xCA6A, 0xCA4A, 0xCA2A, 0xCA0A, 0xC9EA, 0xC9CA, 0xC9AA, 0xC98A,
0xC96A, 0xC94A, 0xC92A, 0xC90A, 0xC8EA, 0xC8CA, 0xC8AA, 0xC88A, 0xC86A, 0xC84A, 0xC82A, 0xC80A, 0xC7EA, 0xC7CA, 0xC7AA, 0xC78A,
0xC76A, 0xC74A, 0xC72A, 0xC70A, 0xC6EA, 0xC6CA, 0xC6AA, 0xC68A, 0xC66A, 0xC64A, 0xC62A, 0xC60A, 0xC5EA, 0xC5CA, 0xC5AA, 0xC58A,
0xC56A, 0xC54A, 0xC52A, 0xC50A, 0xC4EA, 0xC4CA, 0xC4AA, 0xC48A, 0xC46A, 0xC44A, 0xC42A, 0xC40A, 0xC3EA, 0xC3CA, 0xC3AA, 0xC38A,
0xC36A, 0xC34A, 0xC32A, 0xC30A, 0xC2EA, 0xC2CA, 0xC2AA, 0xC28A, 0xC26A, 0xC24A, 0xC22A, 0xC20A, 0xC1EA, 0xC1CA, 0xC1AA, 0xC18A,
0xC16A, 0xC14A, 0xC12A, 0xC10A, 0xC0EA, 0xC0CA, 0xC0AA, 0xC08A, 0xC06A, 0xC04A, 0xC02A, 0xC00A, 0xBFEA, 0xBFCA, 0xBFAA, 0xBF8A,
0xBF6A, 0xBF4A, 0xBF2A, 0xBF0A, 0xBEEA, 0xBECA, 0xBEAA, 0xBE8A, 0xBE6A, 0xBE4A, 0xBE2A, 0xBE0A, 0xBDEA, 0xBDCA, 0xBDAA, 0xBD8A,
0xBD6A, 0xBD4A, 0xBD2A, 0xBD0A, 0xBCEA, 0xBCCA, 0xBCAA, 0xBC8A, 0xBC6A, 0xBC4A, 0xBC2A, 0xBC0A, 0xBBEA, 0xB2E0, 0xB568, 0xB548,
0xBB6A, 0xBB4A, 0xBB2A, 0xBB0A, 0xBAEA, 0xBACA, 0xBAAA, 0xBA8A, 0xBA6A, 0xBA4A, 0xBA2A, 0xBA0A, 0xB9EA, 0xB9CA, 0xB9AA, 0xB98A,
0xB96A, 0xB94A, 0xB92A, 0xB90A, 0xB8EA, 0xB8CA, 0xB8AA, 0xB88A, 0xB86A, 0xB84A, 0xB82A, 0xB80A, 0xB7EA, 0xB7CA, 0xB7AA, 0xB78A,
0xB76A, 0xB74A, 0xB72A, 0xB70A, 0xB6EA, 0xB6CA, 0xB6AA, 0xB68A, 0xB66A, 0xB64A, 0xB62A, 0xB60A, 0xB5EA, 0xB5CA, 0xB5AA, 0xB58A,
0xB56A, 0xB54A, 0xB52A, 0xB50A, 0xB4EA, 0xB4CA, 0xB4AA, 0xB48A, 0xB46A, 0xB44A, 0xB42A, 0xB40A, 0xB3EA, 0xB3CA, 0xB3AA, 0xB38A,
0xB36A, 0xB34A, 0xB32A, 0xB30A, 0xB2EA, 0xB2CA, 0xB2AA, 0xB28A, 0xB26A, 0xB24A, 0xB22A, 0xB20A, 0xB1EA, 0xB1CA, 0xB1AA, 0xB18A,
0xB16A, 0xB14A, 0xB12A, 0xB10A, 0xB0EA, 0xB0CA, 0xB0AA, 0xB08A, 0xB06A, 0xB04A, 0xB02A, 0xB00A, 0xAFEA, 0xAFCA, 0xAFAA, 0xAF8A,
0xAF6A, 0xAF4A, 0xAF2A, 0xAF0A, 0xAEEA, 0xAECA, 0xAEAA, 0xAE8A, 0xAE6A, 0xAE4A, 0xAE2A, 0xAE0A, 0xADEA, 0xADCA, 0xADAA, 0xAD8A,
0xAD6A, 0xAD4A, 0xAD2A, 0xAD0A, 0xACEA, 0xACCA, 0xACAA, 0xAC8A, 0xAC6A, 0xAC4A, 0xAC2A, 0xAC0A, 0xABEA, 0xABCA, 0xABAA, 0xAB8A,
0xAB6A, 0xAB4A, 0xAB2A, 0xAB0A, 0xAAEA, 0xAACA, 0xAAAA, 0xAA8A, 0xAA6A, 0xAA4A, 0xAA2A, 0xAA0A, 0xA9EA, 0xA9CA, 0xA9AA, 0xA98A,
0xA96A, 0xA94A, 0xA92A, 0xA90A, 0xA8EA, 0xA8CA, 0xA8AA, 0xA88A, 0xA86A, 0xA84A, 0xA82A, 0xA80A, 0xA7EA, 0xA7CA, 0xA7AA, 0xA78A,
0xA76A, 0xA74A, 0xA72A, 0xA70A, 0xA6EA, 0xA6CA, 0xA6AA, 0xA68A, 0xA66A, 0xA64A, 0xA62A, 0xA60A, 0xA5EA, 0xA5CA, 0xA5AA, 0xA58A,
0xA56A, 0xA54A, 0xA52A, 0xA50A, 0xA4EA, 0xA4CA, 0xA4AA, 0xA48A, 0xA46A, 0xA44A, 0xA42A, 0xA40A, 0xA3EA, 0xA3CA, 0xA3AA, 0xA38A,
0xA36A, 0xA34A, 0xA32A, 0xA30A, 0xA2EA, 0xA2CA, 0xA2AA, 0xA28A, 0xA26A, 0xA24A, 0xA22A, 0xA20A, 0xA1EA, 0xA1CA, 0xA1AA, 0xA18A,
0xA16A, 0xA14A, 0xA12A, 0xA10A, 0xA0EA, 0xA0CA, 0xA0AA, 0xA08A, 0xA06A, 0xA04A, 0xA02A, 0xA00A, 0x9FEA, 0x9FCA, 0x9FAA, 0x9F8A,
0x9F6A, 0x9F4A, 0x9F2A, 0x9F0A, 0x9EEA, 0x9ECA, 0x9EAA, 0x9E8A, 0x9E6A, 0x9E4A, 0x9E2A, 0x9E0A, 0x9DEA, 0x9DCA, 0x9DAA, 0x9D8A,
0x9D6A, 0x9D4A, 0x9D2A, 0x9D0A, 0x9CEA, 0x9CCA, 0x9CAA, 0x9C8A, 0x9C6A, 0x9C4A, 0x9C2A, 0x9C0A, 0x9BEA, 0x9BCA, 0x9BAA, 0x9B8A,
0x9B6A, 0x9B4A, 0x9B2A, 0x9B0A, 0x9AEA, 0x9ACA, 0x9AAA, 0x9A8A, 0x9A6A, 0x9A4A, 0x9A2A, 0x9A0A, 0x99EA, 0x99CA, 0x99AA, 0x998A,
0x996A, 0x994A, 0x992A, 0x990A, 0x98EA, 0x98CA, 0x98AA, 0x988A, 0x986A, 0x984A, 0x982A, 0x980A, 0x97EA, 0x97CA, 0x97AA, 0x978A,
0x976A, 0x974A, 0x972A, 0x970A, 0x96EA, 0x96CA, 0x96AA, 0x968A, 0x966A, 0x964A, 0x962A, 0x960A, 0x95EA, 0x95CA, 0x95AA, 0x958A,
0x956A, 0x954A, 0x952A, 0x950A, 0x94EA, 0x94CA, 0x94AA, 0x948A, 0x946A, 0x944A, 0x942A, 0x940A, 0x93EA, 0x93CA, 0x93AA, 0x938A,
0x936A, 0x934A, 0x932A, 0x930A, 0x92EA, 0x92CA, 0x92AA, 0x928A, 0x926A, 0x924A, 0x922A, 0x920A, 0x91EA, 0x91CA, 0x91AA, 0x918A,
0x916A, 0x914A, 0x912A, 0x910A, 0x90EA, 0x90CA, 0x90AA, 0x908A, 0x906A, 0x904A, 0x902A, 0x900A, 0x8FEA, 0x8FCA, 0x8FAA, 0x8F8A,
0x8F6A, 0x8F4A, 0x8F2A, 0x8F0A, 0x8EEA, 0x8ECA, 0x8EAA, 0x8E8A, 0x8E6A, 0x8E4A, 0x8E2A, 0x8E0A, 0x8DEA, 0x8DCA, 0x8DAA, 0x8D8A,
0x8D6A, 0x8D4A, 0x8D2A, 0x8D0A, 0x8CEA, 0x8CCA, 0x8CAA, 0x8C8A, 0x8C6A, 0x8C4A, 0x8C2A, 0x8C0A, 0x8BEA, 0x8BCA, 0x8BAA, 0x8B8A,
0x8B6A, 0x8B4A, 0x8B2A, 0x8B0A, 0x8AEA, 0x8ACA, 0x8AAA, 0x8A8A, 0x8A6A, 0x8A4A, 0x8A2A, 0x8A0A, 0x89EA, 0x89CA, 0x89AA, 0x898A,
0x896A, 0x894A, 0x892A, 0x890A, 0x88EA, 0x88CA, 0x88AA, 0x888A, 0x886A, 0x884A, 0x882A, 0x880A, 0x87EA, 0x87CA, 0x87AA, 0x878A,
0x876A, 0x874A, 0x872A, 0x870A, 0x86EA, 0x86CA, 0x86AA, 0x868A, 0x866A, 0x864A, 0x862A, 0x860A, 0x85EA, 0x85CA, 0x85AA, 0x858A,
0x856A, 0x854A, 0x852A, 0x850A, 0x84EA, 0x84CA, 0x84AA, 0x848A, 0x846A, 0x844A, 0x842A, 0x840A, 0x83EA, 0x83CA, 0x83AA, 0x838A,
0x836A, 0x834A, 0x832A, 0x830A, 0x82EA, 0x82CA, 0x82AA, 0x828A, 0x826A, 0x824A, 0x822A, 0x820A, 0x81EA, 0x81CA, 0x81AA, 0x818A,
0x816A, 0x814A, 0x812A, 0x810A, 0x80EA, 0x80CA, 0x80AA, 0x808A, 0x806A, 0x804A, 0x802A, 0x800A, 0x7FEA, 0x7FCA, 0x7FAA, 0x7F8A,
0x7F6A, 0x7F4A, 0x7F2A, 0x7F0A, 0x7EEA, 0x7ECA, 0x7EAA, 0x7E8A, 0x7E6A, 0x7E4A, 0x7E2A, 0x7E0A, 0x7DEA, 0x7DCA, 0x7DAA, 0x7D8A,
0x7D6A, 0x7D4A, 0x7D2A, 0x7D0A, 0x7CEA, 0x7CCA, 0x7CAA, 0x7C8A, 0x7C6A, 0x7C4A, 0x7C2A, 0x7C0A, 0x7BEA, 0x7BCA, 0x7BAA, 0x7B8A,
0x7B6A, 0x7B4A, 0x7B2A, 0x7B0A, 0x7AEA, 0x7ACA, 0x7AAA, 0x7A8A, 0x7A6A, 0x7A4A, 0x7A2A, 0x7A0A, 0x79EA, 0x79CA, 0x79AA, 0x798A,
0x796A, 0x794A, 0x792A, 0x790A, 0x78EA, 0x78CA, 0x78AA, 0x788A, 0x786A, 0x784A, 0x782A, 0x780A, 0x77EA, 0x77CA, 0x77AA, 0x778A,
0x776A, 0x774A, 0x772A, 0x770A, 0x76EA, 0x76CA, 0x76AA, 0x768A, 0x766A, 0x764A, 0x762A, 0x760A, 0x75EA, 0x75CA, 0x75AA, 0x758A,
0x756A, 0x754A, 0x752A, 0x750A, 0x74EA, 0x74CA, 0x74AA, 0x748A, 0x746A, 0x744A, 0x742A, 0x740A, 0x73EA, 0x73CA, 0x73AA, 0x738A,
0x736A, 0x734A, 0x732A, 0x730A, 0x72EA, 0x72CA, 0x72AA, 0x728A, 0x726A, 0x724A, 0x722A, 0x720A, 0x71EA, 0x71CA, 0x71AA, 0x718A,
0x716A, 0x714A, 0x712A, 0x710A, 0x70EA, 0x70CA, 0x70AA, 0x708A, 0x706A, 0x704A, 0x702A, 0x700A, 0x6FEA, 0x6FCA, 0x6FAA, 0x6F8A,
0x6F6A, 0x6F4A, 0x6F2A, 0x6F0A, 0x6EEA, 0x6ECA, 0x6EAA, 0x6E8A, 0x6E6A, 0x6E4A, 0x6E2A, 0x6E0A, 0x6DEA, 0x6DCA, 0x6DAA, 0x6D8A,
0x6D6A, 0x6D4A, 0x6D2A, 0x6D0A, 0x6CEA, 0x6CCA, 0x6CAA, 0x6C8A, 0x6C6A, 0x6C4A, 0x6C2A, 0x6C0A, 0x6BEA, 0x6BCA, 0x6BAA, 0x6B8A,
0x6B6A, 0x6B4A, 0x6B2A, 0x6B0A, 0x6AEA, 0x6ACA, 0x6AAA, 0x6A8A, 0x6A6A, 0x6A4A, 0x6A2A, 0x6A0A, 0x69EA, 0x60F0, 0x6368, 0x6348,
0x696A, 0x694A, 0x692A, 0x690A, 0x68EA, 0x68CA, 0x68AA, 0x688A, 0x686A, 0x684A, 0x682A, 0x680A, 0x67EA, 0x67CA, 0x67AA, 0x678A,
0x676A, 0x674A, 0x672A, 0x670A, 0x66EA, 0x66CA, 0x66AA, 0x668A, 0x666A, 0x664A, 0x662A, 0x660A, 0x65EA, 0x65CA, 0x65AA, 0x658A,
0x656A, 0x654A, 0x652A, 0x650A, 0x6B26, 0x6DE1, 0x6E9C, 0x5E48, 0x5E28, 0x5E08, 0x5DE8, 0x5DC8, 0x5DA8, 0x5D88, 0x5D68, 0x5D48,
0x5D28, 0x5D08, 0x5CE8, 0x5CC8, 0x5CA8, 0x5C88, 0x5C68, 0x5C48, 0x5C28, 0x5C08, 0x5BE8, 0x5BC8, 0x5BA8, 0x5B88, 0x5B68, 0x5B48,
0x5B28, 0x5B08, 0x5AE8, 0x5AC8, 0x5AA8, 0x5A88, 0x5A68, 0x5A48, 0x5A28, 0x5A08, 0x59E8, 0x59C8, 0x59A8, 0x5988, 0x5968, 0x5948,
0x5928, 0x5908, 0x58E8, 0x58C8, 0x58A8, 0x5888, 0x5868, 0x5848, 0x5828, 0x5808, 0x57E8, 0x57C8, 0x57A8, 0x5788, 0x5768, 0x5748,
0x5D6A, 0x5D4A, 0x5D2A, 0x5D0A, 0x5CEA, 0x5CCA, 0x5CAA, 0x5C8A, 0x5C6A, 0x5C4A, 0x5C2A, 0x5C0A, 0x5BEA, 0x5BCA, 0x5BAA, 0x5B8A,
0x5B6A, 0x5B4A, 0x5B2A, 0x5B0A, 0x5AEA, 0x5ACA, 0x5AAA, 0x5A8A, 0x5A6A, 0x5A4A, 0x5A2A, 0x5A0A, 0x59EA, 0x59CA, 0x59AA, 0x598A,
0x596A, 0x594A, 0x592A, 0x590A, 0x58EA, 0x58CA, 0x58AA, 0x588A, 0x586A, 0x584A, 0x582A, 0x580A, 0x57EA, 0x57CA, 0x57AA, 0x578A,
0x576A, 0x574A, 0x572A, 0x570A, 0x56EA, 0x56CA, 0x56AA, 0x568A, 0x566A, 0x564A, 0x562A, 0x560A, 0x55EA, 0x55CA, 0x55AA, 0x558A,
0x556A, 0x554A, 0x552A, 0x550A, 0x54EA, 0x54CA, 0x54AA, 0x548A, 0x546A, 0x544A, 0x542A, 0x540A, 0x53EA, 0x53CA, 0x53AA, 0x538A,
0x536A, 0x534A, 0x532A, 0x530A, 0x52EA, 0x52CA, 0x52AA, 0x528A, 0x526A, 0x524A, 0x522A, 0x520A, 0x51EA, 0x51CA, 0x51AA, 0x518A,
0x516A, 0x514A, 0x512A, 0x510A, 0x50EA, 0x50CA, 0x50AA, 0x508A, 0x506A, 0x504A, 0x502A, 0x500A, 0x4FEA, 0x4FCA, 0x4FAA, 0x4F8A,
0x4F6A, 0x4F4A, 0x4F2A, 0x4F0A, 0x4EEA, 0x4ECA, 0x4EAA, 0x4E8A, 0x4E6A, 0x4E4A, 0x4E2A, 0x4E0A, 0x4DEA, 0x4DCA, 0x4DAA, 0x4D8A,
0x4D6A, 0x4D4A, 0x4D2A, 0x4D0A, 0x4CEA, 0x4CCA, 0x4CAA, 0x4C8A, 0x4C6A, 0x4C4A, 0x4C2A, 0x4C0A, 0x4BEA, 0x4BCA, 0x4BAA, 0x4B8A,
0x4B6A, 0x4B4A, 0x4B2A, 0x4B0A, 0x4AEA, 0x4ACA, 0x4AAA, 0x4A8A, 0x4A6A, 0x4A4A, 0x4A2A, 0x4A0A, 0x49EA, 0x49CA, 0x49AA, 0x498A,
0x496A, 0x494A, 0x492A, 0x490A, 0x48EA, 0x48CA, 0x48AA, 0x488A, 0x486A, 0x484A, 0x482A, 0x480A, 0x47EA, 0x47CA, 0x47AA, 0x478A,
0x476A, 0x474A, 0x472A, 0x470A, 0x46EA, 0x46CA, 0x46AA, 0x468A, 0x466A, 0x464A, 0x462A, 0x460A, 0x45EA, 0x45CA, 0x45AA, 0x458A,
0x456A, 0x454A, 0x452A, 0x450A, 0x44EA, 0x44CA, 0x44AA, 0x448A, 0x446A, 0x444A, 0x442A, 0x440A, 0x43EA, 0x43CA, 0x43AA, 0x438A,
0x436A, 0x434A, 0x432A, 0x430A, 0x42EA, 0x42CA, 0x42AA, 0x428A, 0x426A, 0x424A, 0x422A, 0x420A, 0x41EA, 0x41CA, 0x41AA, 0x418A,
0x416A, 0x414A, 0x412A, 0x410A, 0x40EA, 0x40CA, 0x40AA, 0x408A, 0x406A, 0x404A, 0x402A, 0x400A, 0x3FEA, 0x3FCA, 0x3FAA, 0x3F8A,
0x3F6A, 0x3F4A, 0x3F2A, 0x3F0A, 0x3EEA, 0x3ECA, 0x3EAA, 0x3E8A, 0x3E6A, 0x3E4A, 0x3E2A, 0x3E0A, 0x3DEA, 0x3DCA, 0x3DAA, 0x3D8A,
0x3D6A, 0x3D4A, 0x3D2A, 0x3D0A, 0x3CEA, 0x3CCA, 0x3CAA, 0x3C8A, 0x3C6A, 0x3C4A, 0x3C2A, 0x3C0A, 0x3BEA, 0x3BCA, 0x3BAA, 0x3B8A,
0x3B6A, 0x3B4A, 0x3B2A, 0x3B0A, 0x3AEA, 0x3ACA, 0x3AAA, 0x3A8A, 0x3A6A, 0x3A4A, 0x3A2A, 0x3A0A, 0x39EA, 0x39CA, 0x39AA, 0x398A,
0x396A, 0x394A, 0x392A, 0x390A, 0x38EA, 0x38CA, 0x38AA, 0x388A, 0x386A, 0x384A, 0x382A, 0x380A, 0x37EA, 0x37CA, 0x37AA, 0x378A,
0x376A, 0x374A, 0x372A, 0x370A, 0x36EA, 0x36CA, 0x36AA, 0x368A, 0x366A, 0x364A, 0x362A, 0x360A, 0x35EA, 0x35CA, 0x35AA, 0x358A,
0x356A, 0x354A, 0x352A, 0x350A, 0x34EA, 0x34CA, 0x34AA, 0x348A, 0x346A, 0x344A, 0x342A, 0x340A, 0x33EA, 0x33CA, 0x33AA, 0x338A,
0x336A, 0x334A, 0x332A, 0x330A, 0x32EA, 0x32CA, 0x32AA, 0x328A, 0x326A, 0x324A, 0x322A, 0x320A, 0x31EA, 0x28F2, 0x2B68, 0x2B48,
0x3C2B, 0x3C0B, 0x3BEB, 0x3BCB, 0x3BAB, 0x3B8B, 0x3B6B, 0x3B4B, 0x3B2B, 0x3B0B, 0x3AEB, 0x3ACB, 0x3AAB, 0x3A8B, 0x3A6B, 0x3A4B,
0x3A2B, 0x3A0B, 0x39EB, 0x39CB, 0x39AB, 0x398B, 0x396B, 0x394B, 0x392B, 0x390B, 0x38EB, 0x38CB, 0x38AB, 0x388B, 0x386B, 0x384B,
0x382B, 0x380B, 0x37EB, 0x37CB, 0x37AB, 0x378B, 0x376B, 0x374B, 0x372B, 0x370B, 0x36EB, 0x36CB, 0x36AB, 0x368B, 0x366B, 0x364B,
0x362B, 0x360B, 0x35EB, 0x35CB, 0x35AB, 0x358B, 0x356B, 0x354B, 0x352B, 0x350B, 0x34EB, 0x34CB, 0x34AB, 0x348B, 0x346B, 0x344B,
0x344B, 0x342B, 0x340B, 0x33EB, 0x33CB, 0x33AB, 0x338B, 0x336B, 0x334B, 0x332B, 0x330B, 0x32EB, 0x32CB, 0x32AB, 0x328B, 0x326B,
0x324B, 0x322B, 0x320B, 0x31EB, 0x31CB, 0x31AB, 0x318B, 0x316B, 0x314B, 0x312B, 0x310B, 0x30EB, 0x30CB, 0x30AB, 0x308B, 0x306B,
0x304B, 0x302B, 0x300B, 0x2FEB, 0x2FCB, 0x2FAB, 0x2F8B, 0x2F6B, 0x2F4B, 0x2F2B, 0x2F0B, 0x2EEB, 0x2ECB, 0x2EAB, 0x2E8B, 0x2E6B,
0x2E4B, 0x2E2B, 0x2E0B, 0x2DEB, 0x2DCB, 0x2DAB, 0x2D8B, 0x2D6B, 0x2D4B, 0x2D2B, 0x2D0B, 0x2CEB, 0x2CCB, 0x2CAB, 0x2C8B, 0x2C6B,
0x2C4B, 0x2C2B, 0x2C0B, 0x2BEB, 0x2BCB, 0x2BAB, 0x2B8B, 0x2B6B, 0x2B4B, 0x2B2B, 0x2B0B, 0x2AEB, 0x2ACB, 0x2AAB, 0x2A8B, 0x2A6B,
0x2A4B, 0x2A2B, 0x2A0B, 0x29EB, 0x29CB, 0x29AB, 0x298B, 0x296B, 0x294B, 0x292B, 0x290B, 0x28EB, 0x28CB, 0x28AB, 0x288B, 0x286B,
0x284B, 0x282B, 0x280B, 0x27EB, 0x27CB, 0x27AB, 0x278B, 0x276B, 0x274B, 0x272B, 0x270B, 0x26EB, 0x26CB, 0x26AB, 0x268B, 0x266B,
0x264B, 0x262B, 0x260B, 0x25EB, 0x25CB, 0x25AB, 0x258B, 0x256B, 0x254B, 0x252B, 0x250B, 0x24EB, 0x24CB, 0x24AB, 0x248B, 0x246B,
0x244B, 0x242B, 0x240B, 0x23EB, 0x23CB, 0x23AB, 0x238B, 0x236B, 0x234B, 0x232B, 0x230B, 0x22EB, 0x22CB, 0x22AB, 0x228B, 0x226B,
0x224B, 0x222B, 0x220B, 0x21EB, 0x21CB, 0x21AB, 0x218B, 0x216B, 0x214B, 0x212B, 0x210B, 0x20EB, 0x20CB, 0x20AB, 0x208B, 0x206B,
0x204B, 0x202B, 0x200B, 0x1FEB, 0x1FCB, 0x1FAB, 0x1F8B, 0x1F6B, 0x1F4B, 0x1F2B, 0x1F0B, 0x1EEB, 0x1ECB, 0x1EAB, 0x1E8B, 0x1E6B,
0x1E4B, 0x1E2B, 0x1E0B, 0x1DEB, 0x1DCB, 0x1DAB, 0x1D8B, 0x1D6B, 0x1D4B, 0x1D2B, 0x1D0B, 0x1CEB, 0x1CCB, 0x1CAB, 0x1C8B, 0x1C6B,
0x1C4B, 0x1C2B, 0x1C0B, 0x1BEB, 0x1BCB, 0x1BAB, 0x1B8B, 0x1B6B, 0x106A, 0x104A, 0x102A, 0x100A, 0xFEA, 0xFCA, 0xFAA, 0xF8A,
0xF6A, 0x668, 0x8E8, 0x8C8, 0x8A8, 0x888, 0x868, 0x848, 0x7D7, 0x194B, 0x7B6, 0xD1C, 0xCFC, 0xCB2, 0xCA9, 0xC9C,
0xC7C, 0xC5C, 0xC3C, 0xC1C, 0xBFC, 0xBDC, 0xBBC, 0xB9C, 0xB7C, 0xB5E, 0xB2C, 0xB1C, 0xAB8, 0xADC, 0xA9C, 0x2C2,
0x528, 0x166B, 0x1667, 0x3FF, 0x9FC, 0x9DC, 0x9BC, 0x659, 0xBB8, 0x15A7, 0xFC6, 0x1C0, 0x1B1, 0x9CB, 0x82C, 0x1285,
};
static uint16_t Data[] = {
0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082,
0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3E80, 0x3E80, 0x3001, 0x3082, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x5B88, 0x3E80, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5198, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x3E80, 0x3E80, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202,
0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202,
0x5202, 0x2E82, 0x3E80, 0x5198, 0x2A14, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606,
0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4686, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606,
0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x1A1B, 0x1A1B, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4584, 0x3E80, 0x3E80, 0x3E80, 0x298,
0x3E80, 0x298, 0x6615, 0x6696, 0x298, 0x1A97, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x4584, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x4584,
0x4584, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x4584,
0x4584, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x2E82,
0x7282, 0x2E82, 0x3E80, 0x2E82, 0x4902, 0x7481, 0x7481, 0x7481, 0x7481, 0x7383, 0x1A1B, 0x1A1B, 0x1A1B, 0x6D82, 0x6D82, 0x4902,
0x4902, 0x3E80, 0x3E80, 0x2E82, 0x4902, 0x6E01, 0x6E01, 0x7501, 0x7501, 0x3E80, 0x1A1B, 0x1A1B, 0x1A1B, 0x1B02, 0x1B82, 0x1C02,
0x1C82, 0x1D02, 0x1D82, 0x1E02, 0x1E82, 0x1F02, 0x1F82, 0x2002, 0x2082, 0x2102, 0x2182, 0x2202, 0x2282, 0x2302, 0x2382, 0x2402,
0x2482, 0x2502, 0x2582, 0x2602, 0x2682, 0x2702, 0x2782, 0x455, 0xC99, 0x4D6, 0xC99, 0xF, 0xF, 0xF, 0xF, 0xF,
0x10F, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF,
0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0x8F, 0x10F, 0x8F, 0x18F, 0x10F,
0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0x10F, 0x10F,
0x10F, 0x8F, 0x20C, 0x298, 0x298, 0x318, 0x39A, 0x318, 0x298, 0x298, 0x455, 0x4D6, 0x298, 0x519, 0x598, 0x614,
0x598, 0x698, 0x709, 0x789, 0x809, 0x889, 0x909, 0x989, 0xA09, 0xA89, 0xB09, 0xB89, 0x598, 0x298, 0xC59, 0xC99,
0xC59, 0x298, 0xD01, 0xD81, 0xE01, 0xE81, 0xF01, 0xF81, 0x1001, 0x1081, 0x1101, 0x1181, 0x1201, 0x1281, 0x1301, 0x1381,
0x1401, 0x1481, 0x1501, 0x1581, 0x1601, 0x1681, 0x1701, 0x1781, 0x1801, 0x1881, 0x1901, 0x1981, 0x455, 0x298, 0x4D6, 0x1A1B,
0x1A97, 0x298, 0x298, 0x298, 0xC99, 0x455, 0x4D6, 0x3E80, 0x298, 0x298, 0x298, 0x298, 0x298, 0x298, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x282C, 0x298, 0x39A, 0x39A, 0x39A, 0x39A, 0x289C, 0x289C, 0x1A1B, 0x289C, 0x2902, 0x29DD, 0xC99, 0x2A14, 0x289C, 0x1A1B,
0x2A9C, 0x519, 0x2B0B, 0x2B8B, 0x1A1B, 0x2C02, 0x289C, 0x298, 0x1A1B, 0x2C8B, 0x2902, 0x2D5E, 0x2D8B, 0x2D8B, 0x2D8B, 0x298,
0x298, 0x519, 0x614, 0xC99, 0xC99, 0xC99, 0x3E80, 0x298, 0x39A, 0x318, 0x298, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5405,
0x5405, 0x5405, 0x3E80, 0x5405, 0x3E80, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405,
0x5405, 0x5405, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606,
0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606,
0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x501C, 0x501C, 0x4F81, 0x4F81, 0x4F81, 0x4F81, 0x4F81, 0x4F81, 0x4F81, 0x4F81,
0x4F81, 0x4F81, 0x4F81, 0x4F81, 0x4F81, 0x4F81, 0x4F81, 0x4F81, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01,
0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0xC99,
0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E82, 0x2E82, 0x2E82, 0x4902, 0x4902, 0x2E82, 0x2E82, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x2E82, 0x2E82, 0x2E82, 0x2E82, 0x2E82, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5305, 0x4606, 0x5305, 0x5305, 0x3E80, 0x5305, 0x5305, 0x3E80, 0x5305, 0x5305, 0x5305, 0x5305,
0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405,
0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5398, 0x5405, 0x4606, 0x4606, 0x4606, 0x4606,
0x4606, 0x4606, 0x4606, 0x5087, 0x5087, 0x4606, 0x5087, 0x5087, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x2D8B, 0x2D8B, 0x2D8B, 0x2D8B, 0x2D8B, 0x2D8B, 0x2D8B, 0x2D8B,
0x2D8B, 0x2D8B, 0x2D8B, 0x2D8B, 0x840B, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x2E82, 0x3001,
0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001,
0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5C09, 0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089, 0x4606,
0x4606, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x1A1B,
0x1A1B, 0x4701, 0x298, 0x4781, 0x4781, 0x4781, 0x3E80, 0x4801, 0x3E80, 0x4881, 0x4881, 0x4902, 0x2E01, 0x2E01, 0x2E01, 0x2E01,
0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2F02, 0x2F02, 0x2F02, 0x2F02,
0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02,
0x2F02, 0x2F02, 0x2F02, 0xC99, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F82, 0x2F02, 0x2F02, 0x4A82, 0x2F02,
0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x4B02, 0x4B82, 0x4B82, 0x3E80, 0x4C02, 0x4C82, 0x4D01, 0x4D01,
0x4D01, 0x4D82, 0x4E02, 0x2902, 0x3E80, 0x3E80, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082,
0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x2E82, 0x3B81, 0x3C03, 0x3C82, 0x3001, 0x3082, 0x3D81, 0x3E01, 0x3001, 0x3082,
0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3101, 0x3182,
0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x2902, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001,
0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x4E82, 0x4F02, 0x3D02, 0x2902, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5B10, 0x5B10, 0x5B10, 0x5B10, 0x5B10, 0x5B10, 0x7F0B, 0x3E80, 0x3E80,
0x3E80, 0x7F8B, 0x800B, 0x808B, 0x810B, 0x818B, 0x820B, 0x519, 0x519, 0xC99, 0x455, 0x4D6, 0x2902, 0x3301, 0x3001, 0x3082,
0x3001, 0x3082, 0x3381, 0x3001, 0x3082, 0x3401, 0x3401, 0x3001, 0x3082, 0x2902, 0x3481, 0x3501, 0x3581, 0x3001, 0x3082, 0x3401,
0x3601, 0x3682, 0x3701, 0x3781, 0x3001, 0x3082, 0x2902, 0x2902, 0x3701, 0x3801, 0x2902, 0x3881, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3B81, 0x3C03, 0x3C82, 0x3B81, 0x3C03, 0x3C82, 0x3B81, 0x3C03, 0x3C82, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001,
0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3D02, 0x3001, 0x3082, 0x501C, 0x4606, 0x4606, 0x4606,
0x4606, 0x3E80, 0x5087, 0x5087, 0x3E80, 0x3E80, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082,
0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3201, 0x3001,
0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3282, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3901, 0x3001, 0x3082, 0x3901,
0x2902, 0x2902, 0x3001, 0x3082, 0x3901, 0x3001, 0x3082, 0x3981, 0x3981, 0x3001, 0x3082, 0x3001, 0x3082, 0x3A01, 0x3001, 0x3082,
0x2902, 0x3A85, 0x3001, 0x3082, 0x2902, 0x3B02, 0x4D01, 0x3001, 0x3082, 0x3001, 0x3082, 0x3E80, 0x3E80, 0x3001, 0x3082, 0x3E80,
0x3E80, 0x3001, 0x3082, 0x3E80, 0x3E80, 0x3E80, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082,
0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x598, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x5398, 0x3E80, 0x3E80, 0x3E80, 0x5398, 0x5398, 0x5398, 0x5398, 0x5398, 0x5398, 0x5398, 0x5398, 0x5398,
0x5398, 0x5398, 0x5398, 0x5398, 0x5398, 0x3E80, 0x5B10, 0x5405, 0x4606, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405,
0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405,
0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x3E80, 0x3E80, 0x5B10, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01,
0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01,
0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80,
0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5C09, 0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x2902, 0x2902, 0x2902, 0x3F02, 0x3F82, 0x2902, 0x4002, 0x4002, 0x2902, 0x4082,
0x2902, 0x4102, 0x2902, 0x2902, 0x2902, 0x2902, 0x4002, 0x2902, 0x2902, 0x4182, 0x2902, 0x2902, 0x2902, 0x2902, 0x4202, 0x4282,
0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x4282, 0x2902, 0x2902, 0x4302, 0x2902, 0x2902, 0x4382, 0x2902, 0x2902, 0x2902, 0x2902,
0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x4402, 0x2902, 0x2902, 0x4402, 0x2902, 0x2902, 0x2902, 0x2902, 0x4402, 0x2902,
0x4482, 0x4482, 0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x4502, 0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x2902,
0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x3E80, 0x3E80, 0x4584, 0x4584, 0x4584, 0x4584, 0x4584, 0x4584, 0x4584,
0x4584, 0x4584, 0x1A1B, 0x1A1B, 0x4584, 0x4584, 0x4584, 0x4584, 0x4584, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B,
0x1A1B, 0x1A1B, 0x4584, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101,
0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x3E80, 0x3E80, 0x4584, 0x5198, 0x5198,
0x5198, 0x5198, 0x5198, 0x5198, 0x2E01, 0x2E01, 0x3E80, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01,
0x4982, 0x4A02, 0x4A02, 0x4A02, 0x4902, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02,
0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x4F02, 0x4F02, 0x4F02, 0x4F02, 0x4F02, 0x4F02, 0x4F02, 0x4F02, 0x4F02, 0x4F02, 0x4F02,
0x4F02, 0x4F02, 0x4F02, 0x4F02, 0x4F02, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x5198, 0x4606, 0x4606, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x4606, 0x4606,
0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606,
0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x4606, 0x4606, 0x4606, 0x5298, 0x4606, 0x4606, 0x5298, 0x4606, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305,
0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5305, 0x5305,
0x5305, 0x5298, 0x5298, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5C89, 0x5D09,
0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089, 0x640B, 0x648B, 0x650B, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x5B88, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85,
0x3E80, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606,
0x5B88, 0x5B88, 0x5B88, 0x5B88, 0x3E80, 0x4606, 0x4606, 0x4606, 0x3E80, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606,
0x5B88, 0x5B88, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3E80,
0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x5B88, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5C09, 0x5C89, 0x5D09,
0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089, 0x501C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5509, 0x5589, 0x5609, 0x5689, 0x5709, 0x5789, 0x5809, 0x5889, 0x5909,
0x5989, 0x318, 0x5A18, 0x5A18, 0x5398, 0x3E80, 0x3E80, 0x4606, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405,
0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x3E80, 0x3E80, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405,
0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405,
0x5405, 0x5405, 0x5405, 0x5405, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5405, 0x5405, 0x5405, 0x5405,
0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405,
0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x6615, 0x6696, 0x5484, 0x5405,
0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606,
0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x5B88, 0x5198, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x5B88, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x5198, 0x5198, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x5484, 0x5484,
0x4606, 0x4606, 0x289C, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x709, 0x789, 0x809, 0x889, 0x909, 0x989, 0xA09,
0xA89, 0xB09, 0xB89, 0x5405, 0x5405, 0x5405, 0x5A9C, 0x5A9C, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3E80, 0x3A85,
0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x4606, 0x3A85, 0x3A85, 0x4606, 0x4606, 0x4606, 0x4606,
0x4606, 0x4606, 0x3E80, 0x4606, 0x4606, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x5B88, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x4606, 0x3A85, 0x5B88, 0x5B88,
0x5B88, 0x5B88, 0x5B88, 0x3E80, 0x4606, 0x5B88, 0x5B88, 0x3E80, 0x5B88, 0x5B88, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x5B88, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3E80, 0x5198, 0x5198,
0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089, 0x640B,
0x670B, 0x678B, 0x680B, 0x688B, 0x690B, 0x698B, 0x6A0B, 0x6A8B, 0x648B, 0x6B0B, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85,
0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x4606, 0x3A85, 0x5B88, 0x4606, 0x4606, 0x4606, 0x4606,
0x4606, 0x4606, 0x4606, 0x4606, 0x5B88, 0x5B88, 0x5B88, 0x5B88, 0x4606, 0x3E80, 0x3E80, 0x3A85, 0x4606, 0x4606, 0x4606, 0x4606,
0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x4606,
0x3E80, 0x5B88, 0x5B88, 0x5B88, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85,
0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3E80, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3E80, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x4606, 0x3A85, 0x3A85, 0x4606, 0x4606,
0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x39A, 0x39A, 0x39A, 0x39A, 0x39A, 0x39A, 0x39A,
0x39A, 0x39A, 0x39A, 0x39A, 0x39A, 0x39A, 0x39A, 0x39A, 0x39A, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x4606, 0x4606, 0x5198, 0x5198, 0x5C09,
0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089, 0x5198, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x298, 0x298, 0x318, 0x39A, 0x318, 0x298, 0x298,
0x6615, 0x6696, 0x298, 0x519, 0x598, 0x614, 0x598, 0x698, 0x709, 0x789, 0x809, 0x889, 0x909, 0x989, 0xA09, 0xA89,
0xB09, 0xB89, 0x598, 0x298, 0xC99, 0xC99, 0xC99, 0x298, 0x298, 0x298, 0x298, 0x298, 0x298, 0x2A14, 0x298, 0x298,
0x298, 0x298, 0x5B10, 0x5B10, 0x5B10, 0x5B10, 0x3E80, 0x5C09, 0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009,
0x6089, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x5B88, 0x5B88, 0x3E80, 0x3E80,
0x5B88, 0x5B88, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85,
0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x4606, 0x3E80, 0x5B88, 0x5B88, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606,
0x4606, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x5C09, 0x5C89,
0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089, 0x3A85, 0x3A85, 0x39A, 0x39A, 0x610B, 0x618B, 0x620B, 0x628B,
0x630B, 0x638B, 0x501C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x4606, 0x3A85, 0x5B88, 0x5B88, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x4606, 0x4606,
0x5B88, 0x3E80, 0x5B88, 0x5B88, 0x4606, 0x3E80, 0x3E80, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5C09, 0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009,
0x6089, 0x630B, 0x630B, 0x630B, 0x630B, 0x630B, 0x630B, 0x630B, 0x630B, 0x630B, 0x630B, 0x501C, 0x4606, 0x501C, 0x4606, 0x501C,
0x4606, 0x6615, 0x6696, 0x6615, 0x6696, 0x5B88, 0x5B88, 0x4606, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x5B88, 0x3E80,
0x3E80, 0x5B88, 0x5B88, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x5B88, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x5B88, 0x4606,
0x4606, 0x4606, 0x4606, 0x5B88, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x5B88, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x5B88, 0x5B88, 0x5B88, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606,
0x5B88, 0x5B88, 0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x5B88, 0x5B88, 0x3E80, 0x5B88, 0x5B88, 0x5B88, 0x4606, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x4584, 0x3E80, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x5C09,
0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x5C09, 0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606,
0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x5087, 0x5087, 0x5087, 0x5B88, 0x4606, 0x4606, 0x4606, 0x3E80,
0x3E80, 0x5B88, 0x5B88, 0x5B88, 0x3E80, 0x5B88, 0x5B88, 0x5B88, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x5B88, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x5B88, 0x5B88, 0x4606, 0x4606, 0x4606,
0x3E80, 0x4606, 0x3E80, 0x5B88, 0x5B88, 0x5B88, 0x5B88, 0x5B88, 0x5B88, 0x5B88, 0x5B88, 0x4606, 0x5B88, 0x5B88, 0x4606, 0x4606,
0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198,
0x39A, 0x5198, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x4584, 0x4606, 0x4606, 0x4606, 0x4606,
0x4606, 0x4606, 0x4606, 0x4606, 0x5198, 0x5C09, 0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089, 0x5198,
0x5198, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x501C, 0x501C, 0x501C, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198,
0x5198, 0x65B8, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x4606, 0x4606, 0x501C,
0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x4606, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x3E80, 0x3E80, 0x501C, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x289C,
0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x1A97, 0x4584, 0x4584, 0x4584, 0x3E80, 0x5C09, 0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009,
0x6089, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x5B88, 0x5B88, 0x4606,
0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x20C, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x6615, 0x6696, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x5198, 0x5198, 0x5198, 0x6B8B, 0x6C0B, 0x6C8B, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001,
0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x2E82, 0x2E82, 0x2E82,
0x2E82, 0x2E82, 0x6D02, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6E01,
0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6E01,
0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x3E80, 0x3E80, 0x6E01,
0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x3E80, 0x3E80, 0x2E82, 0x6D82, 0x4902, 0x6D82, 0x4902, 0x6D82, 0x4902, 0x6D82, 0x3E80,
0x6E01, 0x3E80, 0x6E01, 0x3E80, 0x6E01, 0x3E80, 0x6E01, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6E01,
0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E82, 0x6E82, 0x6F02, 0x6F02, 0x6F02, 0x6F02, 0x6F82, 0x6F82, 0x7002,
0x7002, 0x7082, 0x7082, 0x7102, 0x7102, 0x3E80, 0x3E80, 0x7182, 0x7182, 0x7182, 0x7182, 0x7182, 0x7182, 0x7182, 0x7182, 0x7203,
0x7203, 0x7203, 0x7203, 0x7203, 0x7203, 0x7203, 0x7203, 0x7182, 0x7182, 0x7182, 0x7182, 0x7182, 0x7182, 0x7182, 0x7182, 0x7203,
0x7203, 0x7203, 0x7203, 0x7203, 0x7203, 0x7203, 0x7203, 0x6D82, 0x6D82, 0x2E82, 0x7282, 0x2E82, 0x3E80, 0x2E82, 0x4902, 0x6E01,
0x6E01, 0x7301, 0x7301, 0x7383, 0x1A1B, 0x7402, 0x1A1B, 0x1B02, 0x1B82, 0x1C02, 0x1C82, 0x1D02, 0x1D82, 0x1E02, 0x1E82, 0x1F02,
0x1F82, 0x2002, 0x2082, 0x2102, 0x2182, 0x2202, 0x2282, 0x2302, 0x2382, 0x2402, 0x2482, 0x2502, 0x2582, 0x2602, 0x2682, 0x2702,
0x2782, 0x6615, 0xC99, 0x6696, 0xC99, 0x3E80, 0x6D82, 0x6D82, 0x4902, 0x4902, 0x2E82, 0x7582, 0x2E82, 0x4902, 0x6E01, 0x6E01,
0x7601, 0x7601, 0x7681, 0x1A1B, 0x1A1B, 0x1A1B, 0x3E80, 0x3E80, 0x2E82, 0x7282, 0x2E82, 0x3E80, 0x2E82, 0x4902, 0x7701, 0x7701,
0x7781, 0x7781, 0x7383, 0x1A1B, 0x1A1B, 0x3E80, 0x20C, 0x20C, 0x20C, 0x20C, 0x20C, 0x20C, 0x20C, 0x782C, 0x20C, 0x20C,
0x20C, 0x788C, 0x5B10, 0x5B10, 0x7910, 0x7990, 0x2A14, 0x7A34, 0x2A14, 0x2A14, 0x2A14, 0x2A14, 0x298, 0x298, 0x7A9D, 0x7B1E,
0x6615, 0x7A9D, 0x7A9D, 0x7B1E, 0x6615, 0x7A9D, 0x298, 0x298, 0x298, 0x298, 0x298, 0x298, 0x298, 0x298, 0x7B8D, 0x7C0E,
0x7C90, 0x7D10, 0x7D90, 0x7E10, 0x7E90, 0x782C, 0x318, 0x318, 0x318, 0x318, 0x318, 0x298, 0x298, 0x298, 0x298, 0x29DD,
0x2D5E, 0x298, 0x298, 0x298, 0x298, 0x1A97, 0x7F0B, 0x2C8B, 0x2B0B, 0x2B8B, 0x7F8B, 0x800B, 0x808B, 0x810B, 0x818B, 0x820B,
0x519, 0x519, 0xC99, 0x455, 0x4D6, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x289C,
0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x4D01, 0x289C, 0x289C, 0x289C, 0x289C, 0x4D01, 0x289C, 0x289C, 0x2902, 0x4D01,
0x4D01, 0x4D01, 0x2902, 0x2902, 0x4D01, 0x4D01, 0x4D01, 0x2902, 0x289C, 0x4D01, 0x289C, 0x289C, 0x289C, 0x4D01, 0x4D01, 0x4D01,
0x4D01, 0x4D01, 0x289C, 0x289C, 0xA20A, 0xA28A, 0xA30A, 0xA38A, 0xA40A, 0xA48A, 0xA50A, 0xA58A, 0xA60A, 0x4606, 0x4606, 0x4606,
0x4606, 0x4606, 0x4606, 0x2A14, 0x4584, 0x4584, 0x4584, 0x4584, 0x4584, 0x289C, 0x289C, 0xA68A, 0xA70A, 0xA78A, 0x3E80, 0x3E80,
0x3E80, 0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x289C, 0x289C, 0x289C, 0x289C,
0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
0x289C, 0x289C, 0x289C, 0xC99, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
0x289C, 0x289C, 0xC99, 0xC99, 0x289C, 0x289C, 0xC99, 0x289C, 0xC99, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0xC99, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x948A, 0x950A, 0x958A, 0x960A, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0xC99, 0xC99, 0xC99, 0xC99, 0xC99, 0x289C, 0x289C,
0x289C, 0x289C, 0x289C, 0xC99, 0xC99, 0x289C, 0x289C, 0x289C, 0x289C, 0x4D01, 0x289C, 0x8281, 0x289C, 0x4D01, 0x289C, 0x8301,
0x8381, 0x4D01, 0x4D01, 0x2A9C, 0x2902, 0x4D01, 0x4D01, 0x289C, 0x4D01, 0x2902, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x2902, 0x289C,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x848A, 0x850A, 0x858A, 0x860A, 0x868A, 0x870A, 0x878A, 0x880A, 0x888A, 0x890A, 0x898A,
0x8A0A, 0x8A8A, 0x8B0A, 0x8B8A, 0x8C0A, 0x8C8A, 0x8D0A, 0x8D8A, 0x8E0A, 0x8E8A, 0x8F0A, 0x8F8A, 0x900A, 0x908A, 0x910A, 0x918A,
0x920A, 0x928A, 0x930A, 0x938A, 0x940A, 0xC99, 0xC99, 0xC59, 0xC59, 0xC99, 0xC99, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59,
0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC99, 0xC99,
0xC99, 0xC99, 0xC99, 0xC59, 0xC59, 0xC59, 0xC59, 0xC99, 0xC99, 0xC99, 0xC99, 0xC99, 0xC99, 0xC99, 0xC99, 0xC99,
0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC99, 0xC99, 0xC59, 0xC59, 0xC99, 0xC99, 0xC99, 0xC99, 0xC59, 0xC59, 0xC59,
0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC99, 0xC99, 0xC59, 0xC59, 0xC59, 0xC59,
0xC99, 0xC99, 0xC99, 0xC99, 0xC99, 0xC59, 0xC99, 0xC99, 0xC99, 0xC99, 0xC99, 0xC99, 0xC99, 0x289C, 0x289C, 0xC99,
0x289C, 0x289C, 0xC99, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0xC99, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x289C, 0x289C, 0x289C, 0x289C,
0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0xC99, 0xC59, 0xC59,
0xC59, 0xC59, 0xC99, 0xC99, 0xC99, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC99, 0xC99, 0xC99, 0xC59, 0x519,
0x519, 0xC99, 0xC59, 0xC59, 0xC99, 0xC99, 0xC99, 0xC59, 0xC59, 0xC59, 0xC59, 0xC99, 0xC59, 0xC99, 0xC59, 0xC99,
0xC99, 0xC99, 0xC99, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC99, 0xC99, 0xC99, 0xC99,
0xC99, 0xC59, 0xC99, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x455,
0x4D6, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x501C, 0x501C, 0x501C, 0x501C,
0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C,
0x501C, 0x501C, 0x501C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C,
0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x9C1C, 0x9C1C, 0x9C1C,
0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C9C, 0x9C9C, 0x9C9C,
0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x7F0B, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0xC59, 0xC99, 0xC59, 0xC99, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC99,
0xC99, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59,
0xC59, 0xC59, 0xC59, 0xC99, 0xC99, 0xC59, 0xC59, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x39A, 0x39A, 0xC99, 0x1A1B, 0x289C, 0x39A, 0x39A, 0x3E80, 0x289C, 0xC99, 0xC99,
0xC99, 0xC99, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5B10, 0x5B10,
0x5B10, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x289C, 0x3E80, 0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x289C, 0x3E80,
0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x840B, 0x9D0B, 0x9D8B, 0x9E0B, 0x9E8B, 0x9F0B, 0x9F8B, 0xA00B, 0xA08B, 0xA10B, 0x840B,
0x9D0B, 0x9D8B, 0x9E0B, 0x9E8B, 0x9F0B, 0x9F8B, 0xA00B, 0xA08B, 0xA10B, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x289C, 0x289C, 0x289C,
0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0xC59, 0xC59, 0xC59, 0xC59, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x501C, 0x289C,
0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x630B, 0x630B, 0x630B, 0x630B, 0x630B, 0x630B, 0x630B,
0x630B, 0x630B, 0x630B, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C,
0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C,
0x501C, 0x501C, 0x501C, 0x3E80, 0x3E80, 0x3E80, 0x501C, 0x610B, 0x618B, 0x620B, 0x628B, 0xA80B, 0xA88B, 0xA90B, 0xA98B, 0xAA0B,
0x640B, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C,
0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x289C, 0x3E80, 0x289C, 0x289C,
0x289C, 0x3E80, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x2C8B, 0x2B0B, 0x2B8B, 0x7F8B,
0x800B, 0x808B, 0x810B, 0x818B, 0x820B, 0x968B, 0x970B, 0x978B, 0x980B, 0x988B, 0x990B, 0x998B, 0x9A0B, 0x9A8B, 0x9B0B, 0x9B8B,
0x2C8B, 0x2B0B, 0x2B8B, 0x7F8B, 0x800B, 0x808B, 0x810B, 0x818B, 0x820B, 0x968B, 0x970B, 0x978B, 0x980B, 0x988B, 0x990B, 0x998B,
0x9A0B, 0x9A8B, 0x9B0B, 0x9B8B, 0x501C, 0x501C, 0x501C, 0x501C, 0x20C, 0x298, 0x298, 0x298, 0x289C, 0x4584, 0x3A85, 0xA18A,
0x455, 0x4D6, 0x455, 0x4D6, 0x455, 0x4D6, 0x455, 0x4D6, 0x455, 0x4D6, 0x289C, 0x289C, 0x455, 0x4D6, 0x455, 0x4D6,
0x455, 0x4D6, 0x455, 0x4D6, 0x2A14, 0x6615, 0x6696, 0x6696, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x4606, 0x4606, 0x1A1B, 0x1A1B, 0x4584, 0x4584, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x501C, 0x501C, 0x630B, 0x630B, 0x630B, 0x630B, 0x501C, 0x501C,
0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93,
0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93,
0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12,
0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12,
0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305,
0x5305, 0x5305, 0x5305, 0x5305, 0x519, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305,
0x5305, 0x5305, 0x3E80, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x3E80, 0x5305, 0x3E80, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80,
0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x298, 0x2A14, 0x2A14, 0x1A97, 0x1A97,
0x6615, 0x6696, 0x6615, 0x6696, 0x6615, 0x6696, 0x6615, 0x6696, 0x6615, 0x6696, 0x6615, 0x6696, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
0x298, 0x298, 0x298, 0x298, 0x1A97, 0x1A97, 0x1A97, 0x598, 0x298, 0x598, 0x3E80, 0x298, 0x598, 0x298, 0x298, 0x2A14,
0x6615, 0x6696, 0x6615, 0x6696, 0x6615, 0x6696, 0x318, 0x298, 0xD01, 0xD81, 0xE01, 0xE81, 0xF01, 0xF81, 0x1001, 0x1081,
0x1101, 0x1181, 0x1201, 0x1281, 0x1301, 0x1381, 0x1401, 0x1481, 0x1501, 0x1581, 0x1601, 0x1681, 0x1701, 0x1781, 0x1801, 0x1881,
0x1901, 0x1981, 0x6615, 0x298, 0x6696, 0x1A1B, 0x1A97,
};
static int16_t Upper[] = {
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0,
0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2E7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFFE0, 0x79,
0x0, 0xFFFF, 0x0, 0xFF18, 0x0, 0xFED4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x61, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x38, 0x0, 0xFFFF, 0xFFFE, 0xFFB1, 0x0, 0x0, 0x0, 0xFF2E, 0xFF32,
0xFF33, 0xFF36, 0xFF35, 0xFF31, 0xFF2F, 0xFF2D, 0xFF2B, 0xFF2A, 0xFF26, 0xFF27, 0xFF25, 0x0, 0x0, 0x54, 0x0, 0x0,
0x0, 0x0, 0x0, 0xFFDA, 0xFFDB, 0xFFE1, 0xFFC0, 0xFFC1, 0xFFC2, 0xFFC7, 0x0, 0xFFD1, 0xFFCA, 0xFFAA, 0xFFB0, 0x0,
0x0, 0x0, 0x0, 0x0, 0xFFD0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFFC5, 0x8, 0x0, 0x4A, 0x56, 0x64,
0x80, 0x70, 0x7E, 0x8, 0x0, 0x9, 0x0, 0x0, 0xE3DB, 0x0, 0x0, 0x7, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0,
0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFFE6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
};
static int16_t Lower[] = {
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0,
0x1, 0x0, 0xFF39, 0x0, 0xFF87, 0x0, 0xD2, 0xCE, 0xCD, 0x4F, 0xCA, 0xCB, 0xCF, 0x0, 0xD3, 0xD1,
0xD5, 0xD6, 0xDA, 0xD9, 0xDB, 0x0, 0x0, 0x2, 0x1, 0x0, 0x0, 0xFF9F, 0xFFC8, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x26, 0x25,
0x40, 0x3F, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x50,
0x0, 0x0, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFFF8, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0xFFF8, 0x0, 0xFFB6, 0xFFF7, 0x0, 0xFFAA, 0xFF9C, 0x0, 0xFF90, 0xFFF9, 0xFF80, 0xFF82,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0xE2A3, 0xDF41, 0xDFBA, 0x0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1A, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
};
static inline int charType(int c) {return Data[Blocks[c>>5]+c & 0xFFFF] & 0x1F;}
static inline bool isLowc(int c) {return charType(c) == CHAR_LOWERCASE;}
static inline bool isUppc(int c) {return charType(c) == CHAR_UPPERCASE;}
static inline bool isLetterOrDigit(int c) {
return (1 << charType(c)) & (CHAR_DIGIT | CHAR_LETTER);
}
static int toUpperCase(int c) {
return c + Upper[Data[Blocks[c>>5]+c & 0xFFFF] >> 7];
}
static int toLowerCase(int c) {
return c + Lower[Data[Blocks[c>>5]+c & 0xFFFF] >> 7];
}
// (low? 'any) -> sym | NIL
any doLowQ(any x) {
x = cdr(x);
return isSym(x = EVAL(car(x))) && isLowc(symChar(name(x)))? x : Nil;
}
// (upp? 'any) -> sym | NIL
any doUppQ(any x) {
x = cdr(x);
return isSym(x = EVAL(car(x))) && isUppc(symChar(name(x)))? x : Nil;
}
// (lowc 'any) -> any
any doLowc(any x) {
int c, i;
any nm;
cell c1, c2;
x = cdr(x);
if (!isSym(x = EVAL(car(x))) || !(c = symChar(name(x))))
return x;
Push(c1, x);
Push(c2, boxChar(toLowerCase(c), &i, &nm));
while (c = symChar(NULL))
charSym(toLowerCase(c), &i, &nm);
drop(c1);
return consStr(data(c2));
}
// (uppc 'any) -> any
any doUppc(any x) {
int c, i;
any nm;
cell c1, c2;
x = cdr(x);
if (!isSym(x = EVAL(car(x))) || !(c = symChar(name(x))))
return x;
Push(c1, x);
Push(c2, boxChar(toUpperCase(c), &i, &nm));
while (c = symChar(NULL))
charSym(toUpperCase(c), &i, &nm);
drop(c1);
return consStr(data(c2));
}
// (fold 'any ['cnt]) -> sym
any doFold(any ex) {
int n, c, i;
any x, nm;
cell c1, c2;
x = cdr(ex);
if (!isSym(x = EVAL(car(x))) || !(c = symChar(name(x))))
return x;
while (!isLetterOrDigit(c))
if (!(c = symChar(NULL)))
return Nil;
Push(c1, x);
n = isCell(x = cddr(ex))? evCnt(ex,x) : 0;
Push(c2, boxChar(toLowerCase(c), &i, &nm));
while (c = symChar(NULL))
if (isLetterOrDigit(c)) {
if (!--n)
break;
charSym(toLowerCase(c), &i, &nm);
}
drop(c1);
return consStr(data(c2));
}
|
#include "contoh_while.h"
#include <stdio.h>
void contohWhile() {
/* definisi variabel lokal */
int a = 10;
/* eksekusi perulangan While */
while( a < 20 ) {
printf("nilai a: %d\n", a);
a++;
}
}
|
#include <std.h>
#include <daemons.h>
#include <effect_cl.h>
#define FAIL(s) return notify_fail(s+"\n")
#define RES "%^RESET%^"
#define COL "%^GREEN%^"
#define COL2 "%^RED%^"
#define MAX_PERC 175
inherit DAEMON;
void start_buff(object, object, int, int, int, int);
void end_buff(class Effect);
int spell() {
object tp = this_player();
if (tp->query_subclass() == "druid" &&
tp->query_skill("nature") >= 120)
return 1;
return 0;
}
string type() { return "faith"; }
void help() {
message("help",
"Syntax: <bearsrage [whom]>\n\n"
"Druids can call on the primal nature of the raging bear "
"and bestow its powers on the target.",
this_player() );
}
int can_cast(object tp, object tgt) {
if (!tp) return 0;
if (environment(tp)->query_property("no magic"))
FAIL("Some force prevents your magic.");
if (tp->query_busy())
FAIL("You are busy.");
if (tp->query_ghost())
FAIL("You cannot call upon such forces in your state.");
if (!tgt)
FAIL("Call it upon whom?");
if (!tgt->is_living())
FAIL("That is not alive.");
if (tgt->query_effect("bearsrage"))
FAIL(
(tgt == tp ? "You are" : capitalize(tgt->query_subjective())+" is")+
" already filled with that power."
);
if (tp->query_mp() < 75)
FAIL("Too low on magic.");
return 1;
}
int cmd_bearsrage(string str) {
object tp = this_player();
object env = environment(tp);
object tgt;
int time, cost, attack, melee, strength;
if (!spell()) return 0;
if (str) {
if (str == "me" || str == "myself")
tgt = tp;
else
tgt = present(str, env);
}
if (!can_cast(tp, tgt)) return 0;
attack = tp->query_base_skill("nature")/5;
melee = tp->query_base_skill("nature")/5;
strength = tp->query_base_stats("wisdom")/4;
time = tp->query_base_stats("wisdom")*7 +
random(tp->query_base_stats("intelligence")*4);
cost = (attack+time)/2;
if (tp->query_mp() < cost)
FAIL("Too low on magic.");
tp->set_magic_round(1);
tp->add_mp(-cost);
tp->add_skill_points("nature", time/20 + 2);
message("magic", COL+"You call upon the primal nature of the "+
COL2+"raging bear"+COL+"!"+RES, tp);
message("magic", COL+tp->query_cap_name()+" calls upon the primal nature "
"of the "+COL2+"raging bear"+COL+"!"+RES, env, tp);
message("magic", COL+"You feel the power of the "+COL2+"raging bear "+
COL+"enter your body!"+RES, tgt);
message("magic", COL+tgt->query_cap_name()+" seems to look stronger."+RES,
env, tgt);
start_buff(tp, tgt, time, attack, melee, strength);
return 1;
}
void start_buff(object tp, object tgt, int time, int attack, int melee, int strength) {
class Effect buff = new(class Effect);
int tmp;
tmp = tgt->query_skill("attack")*MAX_PERC/100;
if (attack > tmp) attack = tmp;
tmp = tgt->query_skill("melee")*MAX_PERC/100;
if (melee > tmp) melee = tmp;
tmp = tgt->query_stats("strength")*MAX_PERC/100;
if (strength > tmp) strength = tmp;
buff = new(class Effect);
buff->name = "bearsrage";
buff->castername = tp->query_name();
buff->caster = tp;
buff->target = tgt;
buff->desc = "You are filled with the power of the raging bear.";
buff->endmessages = ({
COL+"You feel the nature of the raging bear leave you."+RES,
COL+tgt->query_cap_name()+" seems less strong."+RES,
});
buff->misc = ({ attack, melee, strength });
buff->endtime = time()+time;
buff->endfunc = function(class Effect buff) {
object tgt = buff->target;
int *info = buff->misc;
int attack = info[0];
int melee = info[1];
int strength = info[2];
tgt->add_skill_bonus("attack", -attack);
tgt->add_skill_bonus("melee", -melee);
tgt->add_stat_bonus("strength", -strength);
};
tgt->add_skill_bonus("attack", attack);
tgt->add_skill_bonus("melee", melee);
tgt->add_stat_bonus("strength", strength);
tgt->add_effect(buff);
}
void end_buff(class Effect buff) {
object tgt = buff->target;
int *info = buff->misc;
int attack = info[0];
int melee = info[1];
int strength = info[2];
tgt->add_skill_bonus("attack", -attack);
tgt->add_skill_bonus("melee", -melee);
tgt->add_stat_bonus("strength", -strength);
}
|
#include<stdio.h>
int main(){
FILE *fp;
fpos_t pos;
fp=fopen("file.txt","w+");
fputs("Hello", fp);
fgetpos(fp,&pos);
fputs("walk", fp);
fsetpos(fp,&pos);
fputs("world",fp);
fclose(fp);
return 0;
}
|
#include<stdlib.h>
#include<stdio.h>
#define MAX_OP 5
#define operator(ch) ((c=='+')||(c=='-')||(c=='*')||(c=='/'))?1:0
#define operands(ch) ((c)>='a' && (c)<='z')?1:0
#define MAX_ITEM 100
typedef struct tagStack{
int item[MAX_ITEM];
int top;
}Stack;
Stack S;
char op[MAX_OP]={'(', '+', '-', '*', '/'};
char prio[MAX_OP]={0, 1, 1, 2, 2};
void Push(int);
void Pop(int *);
int priority(char ch);
void in_to_post(char *,char *);
int main(void){
int i;
char infix[MAX_ITEM];
char postfix[MAX_ITEM];
S.top = -1;
return 0;
}
void Push(int x){
if(S.top < MAX_ITEM - 1){
S.top++;
S.item[S.top] = x;
}
}
void Pop(int *x){
if(S.top >= 0){
*x = S.item[S.top];
S.top--;
}
}
int priority(char ch){
int i;
for(i = 0; i < MAX_OP; i++){
if(op[i] == ch){
return prio[i];
}
}
return -1;
}
void in_to_post(char *infix, char *postfix){
int i, j, element;
char token;
i = j =0;
}
|
#include <stdio.h>
#include <stdlib.h>
#define LIMIT 100
int stack[LIMIT];
int top;
int i;
int choice;
void push();
int pop();
void display();
int add(int a,int b){
return a+b;
}
int multiply(int a,int b){
return a*b;
}
int main()
{
push(10);
display();
push(-3);
display();
int one = pop();
int two = pop();
int diafora1 = add(one,two) ;
push(diafora1);
display();
push(8);
display();
push(3);
display();
one = pop();
two = pop();
int athroisma1 = add(one,two);
push(athroisma1);
display();
one = pop();
two = pop();
int ginomeno1 = multiply(one,two);
push(ginomeno1);
display();
push(2);
one = pop();
two = pop();
int apotelesma = add(one,two);
push(apotelesma);
display();
}
void push(int element)
{
//int stack[LIMIT], top, element;
if(top == LIMIT- 1)
{
printf("Stack Overflow\n");
}
else
{
top++;
stack[top]=element;
}
}
int pop()
{
int element;
if(top == -1)
{
return -1;
}
else
{
element=stack[top];
top--;
return element;
// The element below the topmost element is deleted
}
}
void display()
{
if(top == -1)
{
printf("Stack underflow\n"); // Stack is empty
}
else if(top > 0)
{
printf("The elements of the stack are:\n");
for(i = top; i >= 0; i--) // top to bottom traversal
{
printf("%d\n",stack[i]);
}
}
}
|
/**
******************************************************************************
* @file rtc.h
* @brief This file contains all the function prototypes for
* the rtc.c file
******************************************************************************
* @attention
*
* <h2><center>© Copyright (c) 2021 STMicroelectronics.
* All rights reserved.</center></h2>
*
* This software component is licensed by ST under Ultimate Liberty license
* SLA0044, the "License"; You may not use this file except in compliance with
* the License. You may obtain a copy of the License at:
* www.st.com/SLA0044
*
******************************************************************************
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __RTC_H__
#define __RTC_H__
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include "main.h"
/* USER CODE BEGIN Includes */
/* USER CODE END Includes */
extern RTC_HandleTypeDef hrtc;
/* USER CODE BEGIN Private defines */
/* USER CODE END Private defines */
void MX_RTC_Init(void);
/* USER CODE BEGIN Prototypes */
extern uint32_t cflags;
#define RTC_USE_INTERNAL 1
#define time_t_O_TICS(_hour,_min) ((_hour*60*60) + (_min*60))
typedef struct {
uint32_t seconds;
uint32_t minutes;
uint32_t hours;
uint32_t day;
uint32_t date;
uint32_t month;
uint32_t year;
} time_t_;
#include "Shared_Libraries/suntracer.h"
char isYearNotLeap(uint32_t uiYear);
void getDateTime(time_t_ *dt);
void getSolarDateTime(time_t_ *dt);
void getGMTDateTime(time_t_ *dt);
uint32_t getSolar_Ticks();
uint32_t getGMT_Ticks();
uint32_t DateTimeToTicks(time_t_ *dt) ;
void TicksToDateTime(uint32_t ulTimeTicks, time_t_ *dt);
void setSolarDateTime(time_t_ *dt);
void setSolarTimeTics(uint32_t ticks);
void setSolarSeconds(uint32_t sec);
void setSolarMinutes(uint32_t min);
void setSolarHours(uint32_t hours);
void setSolarMday(uint32_t mday);
void setSolarMonth(uint32_t mon);
void setSolarYear(uint32_t year);
void setGMTSeconds(uint32_t sec);
void setGMTMinutes(uint32_t min);
void setGMTHours(uint32_t hours);
void setGMTMday(uint32_t mday);
void setGMTMonth(uint32_t mon);
void setGMTYear(uint32_t year);
void Time_add(time_t_ *dt, int sec );
void Time_round(time_t_ *dt, unsigned int sec );
int Time_higherEq(time_t_ *dt1, time_t_ *dt2);
int Time_lower(time_t_ *dt1, time_t_ *dt2);
uint32_t TimeToTics(time_t_ *dt1);
uint32_t TimeStrToTime(char *str, time_t_ * t);
uint32_t TimeStrToTics(char *str);
uint32_t getdoyFromTics(uint32_t tics);
uint32_t getdoy(time_t_ *dt);
void rtc_applay_correction(int secsPerDay);
int rtc_find_correction(int secsPerDay);
void RTC_softwareCorrection(int secsPerDay);
void rtc_apply_correction();
void rtc_init(void);
void RTC_SetCounter(uint32_t ticks);
/* USER CODE END Prototypes */
#ifdef __cplusplus
}
#endif
#endif /* __RTC_H__ */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
/**
* @file calculator.c
* @author Lukas Zronek
* @date 28.10.2016
* @brief a user-friendly calculator (simple)
* @version 1.0
*
*/
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <errno.h>
#include <assert.h>
void print_usage(void);
int main(void)
{
char *line = NULL;
size_t line_length = 0;
char *operand1 = NULL;
char *operand2 = NULL;
char *operator = NULL;
double number1 = 0;
double number2 = 0;
double result = 0;
printf("Press control-D to quit:\n");
while (1) {
printf("> ");
errno = 0;
/* if line != NULL getline() expands the buffer with realloc() */
if (getline(&line, &line_length, stdin) != -1) {
operand1 = strtok(line, " ");
if (operand1 == NULL) {
/* unreachable code:
* operand1 != NULL when line != NULL and line_length > 0 */
assert(0);
}
operator = strtok(NULL, " ");
if (operator == NULL) {
print_usage();
continue;
}
operand2 = strtok(NULL, "\n");
if (operand2 == NULL) {
print_usage();
continue;
}
if (strcmp("Ans", operand1) == 0) {
number1 = result;
} else if (sscanf(operand1, "%lf", &number1) != 1) {
print_usage();
continue;
}
if (strcmp("Ans", operand2) == 0) {
number2 = result;
} else if (sscanf(operand2, "%lf", &number2) != 1) {
print_usage();
continue;
}
if (strcmp("+", operator) == 0) {
result = number1 + number2;
} else if (strcmp("-", operator) == 0) {
result = number1 - number2;
} else if (strcmp("*", operator) == 0) {
result = number1 * number2;
} else if (strcmp("/", operator) == 0) {
if (number2 == 0) {
fprintf(stderr, "ERROR: DIVISION BY ZERO (Operand 2)\n");
continue;
} else {
result = number1 / number2;
}
} else if (strcmp("**", operator) == 0) {
result = pow(number1, number2);
} else if (strcmp("_/", operator) == 0) {
if (number1 < 0) {
fprintf(stderr, "ERROR: Operand 1 must be greater than zero\n");
continue;
} else if (number2 == 0) {
fprintf(stderr, "ERROR: DIVISION BY ZERO (Operand 2)\n");
continue;
} else {
result = pow(number1, 1 / number2);
}
} else if (strcmp("%", operator) == 0) {
result = (number2 / 100) * number1;
} else {
fprintf(stderr, "ERROR: unknown operator\n");
continue;
}
/* result = roundf(result * 100) / 100; */
printf("Ans = %g\n", result);
} else {
if (errno > 0) {
perror("ERROR: Could not read input");
} else { /* probably EOF -> exit */
break;
}
}
}
free(line);
line = NULL;
return EXIT_SUCCESS;
}
void print_usage()
{
printf("Usage: <Number 1> <operator> <Number 2>\n");
}
|
/* Copyright 2020 Jaakko Keränen <jaakko.keranen@iki.fi>
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
#include "playerui.h"
#include "audio/player.h"
#include "paint.h"
#include "util.h"
static const char *volumeChar_(float volume) {
if (volume <= 0) {
return "\U0001f507";
}
if (volume < 0.4f) {
return "\U0001f508";
}
if (volume < 0.8f) {
return "\U0001f509";
}
return "\U0001f50a";
}
void init_PlayerUI(iPlayerUI *d, const iPlayer *player, iRect bounds) {
d->player = player;
d->bounds = bounds;
const int height = height_Rect(bounds);
d->playPauseRect = (iRect){ addX_I2(topLeft_Rect(bounds), gap_UI / 2), init_I2(3 * height / 2, height) };
d->rewindRect = (iRect){ topRight_Rect(d->playPauseRect), init1_I2(height) };
d->menuRect = (iRect){ addX_I2(topRight_Rect(bounds), -height - gap_UI / 2), init1_I2(height) };
d->volumeRect = (iRect){ addX_I2(topLeft_Rect(d->menuRect), -height), init1_I2(height) };
d->volumeAdjustRect = d->volumeRect;
adjustEdges_Rect(&d->volumeAdjustRect, 0, 0, 0, -35 * gap_UI);
d->scrubberRect = initCorners_Rect(topRight_Rect(d->rewindRect), bottomLeft_Rect(d->volumeRect));
/* Volume slider. */ {
d->volumeSlider = shrunk_Rect(d->volumeAdjustRect, init_I2(gap_UI / 2, gap_UI));
adjustEdges_Rect(&d->volumeSlider, 0, -width_Rect(d->volumeRect) - 2 * gap_UI, 0, 5 * gap_UI);
}
}
static void drawPlayerButton_(iPaint *p, iRect rect, const char *label, int font) {
const iInt2 mouse = mouseCoord_Window(get_Window());
const iBool isHover = contains_Rect(rect, mouse);
const iBool isPressed = isHover && (SDL_GetMouseState(NULL, NULL) & SDL_BUTTON_LEFT) != 0;
const int frame = (isPressed ? uiTextCaution_ColorId : isHover ? uiHeading_ColorId : uiAnnotation_ColorId);
iRect frameRect = shrunk_Rect(rect, init_I2(gap_UI / 2, gap_UI));
drawRect_Paint(p, frameRect, frame);
if (isPressed) {
fillRect_Paint(
p,
adjusted_Rect(shrunk_Rect(frameRect, divi_I2(gap2_UI, 2)), zero_I2(), one_I2()),
frame);
}
const int fg = isPressed ? (permanent_ColorId | uiBackground_ColorId) : uiHeading_ColorId;
drawCentered_Text(font, frameRect, iTrue, fg, "%s", label);
}
static int drawSevenSegmentTime_(iInt2 pos, int color, int align, int seconds) { /* returns width */
const uint32_t sevenSegmentDigit = 0x1fbf0;
const int hours = seconds / 3600;
const int mins = (seconds / 60) % 60;
const int secs = seconds % 60;
const int font = uiLabel_FontId;
iString num;
init_String(&num);
if (hours) {
appendChar_String(&num, sevenSegmentDigit + (hours % 10));
appendChar_String(&num, ':');
}
appendChar_String(&num, sevenSegmentDigit + (mins / 10) % 10);
appendChar_String(&num, sevenSegmentDigit + (mins % 10));
appendChar_String(&num, ':');
appendChar_String(&num, sevenSegmentDigit + (secs / 10) % 10);
appendChar_String(&num, sevenSegmentDigit + (secs % 10));
iInt2 size = advanceRange_Text(font, range_String(&num));
if (align == right_Alignment) {
pos.x -= size.x;
}
drawRange_Text(font, pos, color, range_String(&num));
deinit_String(&num);
return size.x;
}
void draw_PlayerUI(iPlayerUI *d, iPaint *p) {
const int playerBackground_ColorId = uiBackground_ColorId;
const int playerFrame_ColorId = uiSeparator_ColorId;
const iBool isAdjusting = (flags_Player(d->player) & adjustingVolume_PlayerFlag) != 0;
fillRect_Paint(p, d->bounds, playerBackground_ColorId);
drawRect_Paint(p, d->bounds, playerFrame_ColorId);
drawPlayerButton_(p,
d->playPauseRect,
isPaused_Player(d->player) ? "\U0001f782" : "\u23f8",
uiContent_FontId);
drawPlayerButton_(p, d->rewindRect, "\u23ee", uiContent_FontId);
drawPlayerButton_(p, d->menuRect, "\U0001d362", uiContent_FontId);
if (!isAdjusting) {
drawPlayerButton_(
p, d->volumeRect, volumeChar_(volume_Player(d->player)), uiContentSymbols_FontId);
}
const int hgt = lineHeight_Text(uiLabel_FontId);
const int yMid = mid_Rect(d->scrubberRect).y;
const float playTime = time_Player(d->player);
const float totalTime = duration_Player(d->player);
const int bright = uiHeading_ColorId;
const int dim = uiAnnotation_ColorId;
int leftWidth = drawSevenSegmentTime_(
init_I2(left_Rect(d->scrubberRect) + 2 * gap_UI, yMid - hgt / 2),
isPaused_Player(d->player) ? dim : bright,
left_Alignment,
iRound(playTime));
int rightWidth = 0;
if (totalTime > 0) {
rightWidth =
drawSevenSegmentTime_(init_I2(right_Rect(d->scrubberRect) - 2 * gap_UI, yMid - hgt / 2),
dim,
right_Alignment,
iRound(totalTime));
}
/* Scrubber. */
const int s1 = left_Rect(d->scrubberRect) + leftWidth + 6 * gap_UI;
const int s2 = right_Rect(d->scrubberRect) - rightWidth - 6 * gap_UI;
const float normPos = totalTime > 0 ? playTime / totalTime : 0.0f;
const int part = (s2 - s1) * normPos;
const int scrubMax = (s2 - s1) * streamProgress_Player(d->player);
drawHLine_Paint(p, init_I2(s1, yMid), part, bright);
drawHLine_Paint(p, init_I2(s1 + part, yMid), scrubMax - part, dim);
const char *dot = "\u23fa";
const int dotWidth = advance_Text(uiLabel_FontId, dot).x;
draw_Text(uiLabel_FontId,
init_I2(s1 * (1.0f - normPos) + s2 * normPos - dotWidth / 2, yMid - hgt / 2),
isPaused_Player(d->player) ? dim : bright,
dot);
/* Volume adjustment. */
if (isAdjusting) {
const iInt2 mouse = mouseCoord_Window(get_Window());
const iBool isHover = contains_Rect(d->volumeRect, mouse) &&
~flags_Player(d->player) & volumeGrabbed_PlayerFlag;
const iBool isPressed = (SDL_GetMouseState(NULL, NULL) & SDL_BUTTON_LEFT) != 0;
iRect adjRect = shrunk_Rect(d->volumeAdjustRect, init_I2(gap_UI / 2, gap_UI));
fillRect_Paint(p, adjRect, playerBackground_ColorId);
drawRect_Paint(p, adjRect, bright);
if (isHover) {
fillRect_Paint(
p,
shrunk_Rect(d->volumeRect, init_I2(gap_UI / 2 + gap_UI / 2, 3 * gap_UI / 2)),
isPressed ? uiTextCaution_ColorId : bright);
}
drawCentered_Text(uiContentSymbols_FontId,
d->volumeRect,
iTrue,
isHover ? playerBackground_ColorId : bright,
volumeChar_(volume_Player(d->player)));
const int volColor =
flags_Player(d->player) & volumeGrabbed_PlayerFlag ? uiTextCaution_ColorId : bright;
const int volPart = volume_Player(d->player) * width_Rect(d->volumeSlider);
const iInt2 volPos = init_I2(left_Rect(d->volumeSlider), mid_Rect(d->volumeSlider).y);
drawHLine_Paint(p, volPos, volPart, volColor);
drawHLine_Paint(p,
addX_I2(volPos, volPart),
width_Rect(d->volumeSlider) - volPart,
dim);
draw_Text(uiLabel_FontId,
init_I2(left_Rect(d->volumeSlider) + volPart - dotWidth / 2, yMid - hgt / 2),
volColor,
dot);
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/ether.h>
#include <pthread.h>
#include <arpa/inet.h>
#include <string.h>
#include <assert.h>
#include <net/ethernet.h>
#define ENTRIES 10
struct bpdu {
uint8_t llc[3], version, type, flags, root_mac[6], bridge_mac[6];
uint16_t protocol, root_pri, bridge_pri, port_id, msg_age,
max_age, hello_time, forward_delay;
uint32_t root_cost;
};
struct entry {
struct ether_addr addr;
short port; //network byte order
int timer, sockfd;
};
struct entry table[ENTRIES];
int wires[ENTRIES];
struct entry emptyEntry = {
.port = -1, .timer = 0
};
struct bpdu bpdu = {
.llc = {66, 66, 3}, .protocol = 0, .version = 0,
.type = 0, .flags = 0, .max_age = 20, .hello_time = 2, .forward_delay = 15
};
void initializeTable() {
for (int i = 0; i < ENTRIES; i++) {
table[i].port = -1;
table[i].timer = 0;
}
}
int addrlen(struct sockaddr_un *a) {
return sizeof(a->sun_family) + 1 + strlen(&a->sun_path[1]);
}
void forward(unsigned char *packet, int entry, int len) {
assert(send(table[entry].sockfd, packet, len, 0) >= 0);
}
void broadcast(unsigned char *packet, int entry, int len) {
for (int i = 0; i < ENTRIES; i++) {
if (table[i].sockfd > 0 && i != entry) {
assert(send(table[i].sockfd, packet, len, 0) >= 0);
}
}
}
int addrInTable(struct ether_addr *dst) {
char tmp1[32], tmp2[32];
for (int i = 0; i < ENTRIES; i++) {
ether_ntoa_r(&table[i].addr, tmp1);
ether_ntoa_r(dst, tmp2);
if (strncmp(tmp1, tmp2, strlen(tmp1)) == 0) {
return i;
}
bzero(tmp1, sizeof(tmp1));
bzero(tmp2, sizeof(tmp2));
}
return -1;
}
int max(int array[], int num) {
int max = -1, i;
for (i = 0; i < num; i++) {
if (array[i] > max) {
max = array[i];
}
}
return max;
}
void removeEntry(int entry) {
printf("Address %s disabled\n", ether_ntoa(&table[entry].addr));
table[entry] = emptyEntry;
}
int socketInTable(int socket) {
for (int i = 0; i < ENTRIES; i++) {
if (table[i].sockfd == socket) {
return i;
}
}
return -1;
}
void *tick(void *i) {
int entry = (int) (intptr_t) i;
while (table[entry].timer <= 15) {
sleep(1);
table[entry].timer++;
}
return NULL;
}
void receive(int sock[], int num) {
int i, len, retval, entry = -1, maxfd = max(sock, num) + 1, connected[num];
unsigned char buf[1500]; /* unsigned so printf %02x works... */
fd_set rfds, wfds;
struct timeval timeout;
bzero(connected, sizeof(connected));
while (1) {
sleep(3);
FD_ZERO(&rfds);
FD_ZERO(&wfds);
for (i = 0; i < num; i++) {
FD_SET(sock[i], &rfds);
FD_SET(sock[i], &wfds);
}
timeout.tv_sec = 4;
timeout.tv_usec = 0;
retval = select(maxfd, &rfds, &wfds, NULL, &timeout);
if (retval == -1)
perror("select()");
else {
for (i = 0; i < num; i++) {
if (FD_ISSET(sock[i], &rfds)) {
if ((len = (int) recv(sock[i], buf, sizeof(buf), 0)) > 0) {
char tmp1[32], tmp2[32];
struct ether_addr *dst = (struct ether_addr *) buf; /* very crude unpacking */
struct ether_addr *src = (struct ether_addr *) &buf[6];
if (addrInTable(src) < 0) {
int newEntry;
for (newEntry = 0; newEntry < ENTRIES; newEntry++) {
if (strncmp(ether_ntoa_r(&table[newEntry].addr, tmp1), "0:0:0:0:0:0", sizeof(tmp1)) == 0) {
break;
}
bzero(tmp1, sizeof(tmp1));
}
memcpy(&table[newEntry].addr, src, 6);
printf("Address %s added\n", ether_ntoa(&table[newEntry].addr));
memcpy(tmp2, &buf[42], sizeof(table[newEntry].port));
table[newEntry].port = ntohs(atoi(tmp2));
table[newEntry].sockfd = sock[i];
}
bzero(tmp1, sizeof(tmp1));
memcmp(tmp1, &buf[30], sizeof(bpdu.root_cost));
bpdu.root_cost = htonl(ntohl(atol(tmp1)) + 10);
memcmp(&buf[30], &bpdu.root_cost, sizeof(bpdu.root_cost));
bzero(tmp1, sizeof(tmp1));
memcmp(&buf[36], bpdu.bridge_mac, sizeof(bpdu.bridge_mac));
memcmp(tmp1, &buf[44], sizeof(bpdu.msg_age));
bpdu.msg_age = htons(ntohs(atol(tmp1)) + 1);
memcmp(&buf[44], &bpdu.msg_age, sizeof(bpdu.root_cost));
if (strncmp(ether_ntoa_r(dst, tmp2), "01:80:c2:00:00:00", sizeof(tmp2)) == 0) {
} else if ((entry = addrInTable(dst)) >= 0) {
if (FD_ISSET(table[addrInTable(dst)].sockfd, &wfds)) {
forward(buf, entry, len);
}
} else {
broadcast(buf, i, len);
}
connected[i] = 1;
}
} else if (connected[i] == 1) {
pthread_t t;
entry = socketInTable(sock[i]);
if (table[entry].timer == 0) {
pthread_create(&t, NULL, tick, (void *) (intptr_t) entry);
}
connected[i] = 0;
} else {
entry = socketInTable(sock[i]);
if (entry >= 0) {
if (table[entry].timer >= 15) {
removeEntry(entry);
}
}
}
}
}
}
}
int main(int argc, char *argv[]) {
int sockfd[argc - 2], i = 0, j;
pthread_t thread;
memcmp(bpdu.bridge_mac, ether_aton(argv[1]), sizeof(bpdu.bridge_mac));
for (j = 2; j < argc; j++) {
wires[i] = atoi(argv[j]);
i++;
}
initializeTable();
for (j = 0; j < argc - 2; j++) {
sockfd[j] = socket(AF_UNIX, SOCK_SEQPACKET, 0);
struct sockaddr_un l_unix = {.sun_family = AF_UNIX, .sun_path = {0,}};
sprintf(&l_unix.sun_path[1], "%s.host-%s (wire %d)", getenv("USER"), argv[1], wires[j]);
bind(sockfd[j], (struct sockaddr *) &l_unix, (socklen_t) addrlen(&l_unix));
struct sockaddr_un w_unix = {.sun_family = AF_UNIX, .sun_path = {0,}};
sprintf(&w_unix.sun_path[1], "%s.wire.%d", getenv("USER"), wires[j]);
if (connect(sockfd[j], (struct sockaddr *) &w_unix, (socklen_t) addrlen(&w_unix)) < 0) {
perror("can't connect");
return EXIT_FAILURE;
}
}
receive(sockfd, argc - 2);
// pthread_create(&thread, NULL, receive, sockfd);
for (;;) {
sleep(2);
}
}
|
/*
* Exported with nin10kit v1.7
* Invocation command was nin10kit --mode=3 --resize=8x8 image_empty image_empty.png
* Time-stamp: Monday 11/04/2019, 19:22:10
*
* Image Information
* -----------------
* image_empty.png 8@8
*
* All bug reports / feature requests are to be filed here https://github.com/TricksterGuy/nin10kit/issues
*/
#ifndef IMAGE_EMPTY_H
#define IMAGE_EMPTY_H
extern const unsigned short image_empty[64];
#define IMAGE_EMPTY_SIZE 128
#define IMAGE_EMPTY_LENGTH 64
#define IMAGE_EMPTY_WIDTH 8
#define IMAGE_EMPTY_HEIGHT 8
#endif
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* actions.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: avogt <avogt@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/07/06 10:52:44 by avogt #+# #+# */
/* Updated: 2021/07/29 11:35:55 by avogt ### ########.fr */
/* */
/* ************************************************************************** */
#include "../includes/philo.h"
int eating(t_philo *philo)
{
long long time;
time = get_ms_time();
if (printing(philo, EATING, time))
return (1);
if (ft_usleep(time, philo->infos->time_to_eat, philo))
return (1);
return (0);
}
int sleeping(t_philo *philo)
{
long long time;
time = get_ms_time();
if (printing(philo, SLEEPING, time))
return (1);
if (ft_usleep(time, philo->infos->time_to_sleep, philo))
return (1);
return (0);
}
int thinking(t_philo *philo)
{
if (printing(philo, THINKING, get_ms_time()))
return (1);
return (0);
}
void take_fork(t_philo *philo, pthread_mutex_t *fork)
{
pthread_mutex_lock(fork);
printing(philo, TAKING_FORK, get_ms_time());
}
|
void handle_hw_int(void) {
/* nothing */
}
int n = 7;
int a[15] = {21, -312, 37, -42, 75, 29, 1324};
int b[15];
void bubble_sort() {
int i, j, tmp;
for (i=0; i<n; ++i) b[i] = a[i];
for (i=0; i<n; ++i) {
for (j=i+1; j<n; ++j) {
if (a[i] > a[j]) {
tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
}
}
}
int main() {
bubble_sort();
return 0;
}
|
#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
int able;
void fork_example()
{
printf("fork number = %d \n",++able);
pid_t pid;
pid = fork();
int a = 5;
if(pid<0)
{
printf("error occured\n");
}
else if(pid==0)
{
printf("%d\n", getpid());
printf("child is executed x = %d \n", a +5);
}
else
{
printf("%d\n",getpid());
printf("parent has x = %d \n",a-5);
}
}
int main()
{
able = 1;
fork_example();
fork_example();
fork_example();
return 0;
}
|
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* License); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* AS IS BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
/*
* Copyright (c) 2021, OPEN AI LAB
* Author: haitao@openailab.com
* Revised: lswang@openailab.com
*/
#pragma once
#include "defines.h"
#include "operator/op.h"
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
struct node;
struct tensor;
struct graph;
/*!
* @struct ir_node_t
* @brief Abstract node intermediate representation
*/
typedef struct node
{
uint16_t index; //!< the index of a node
uint8_t dynamic_shape; //!< flag of dynamic shape
uint8_t input_num; //!< count of input tensor
uint8_t output_num; //!< count of output tensor
uint8_t node_type; //!< type of node: { input, output, intermediate }
int8_t subgraph_idx; //!< id of the owner subgraph
uint16_t* input_tensors; //!< id array of input tensor
uint16_t* output_tensors; //!< id array of output tensor
char* name; //!< name of a node
struct op op; //!< operator of a node
struct graph* graph; //!< pointer of the owner graph
} ir_node_t;
/*!
* @brief Create a node for a graph.
*
* @param [in] ir_graph: specific graph.
* @param [in] node_name: node name.
* @param [in] op_type: operator type, see "op.h".
* @param [in] op_version: operator defined version.
*
* @return The pointer of the node.
*/
ir_node_t* create_ir_node(struct graph* ir_graph, const char* node_name, int op_type, int op_version);
/*!
* @brief Destroy a node.
*
* User should deal with other destroy works, such as ir_node and ir_tensor.
*
* @param [in] ir_graph: specific graph.
* @param [in] ir_node: the tensor pointer.
*/
void destroy_ir_node(struct graph* ir_graph, ir_node_t* ir_node);
/*!
* @brief Set node name from id, for anonymity ones.
*
* @param [in] index: reference id.
*
* @return char array of the name.
*/
char* create_ir_node_name_from_index(int index);
/*!
* @brief Get node id from name, for anonymity ones.
*
* It is possible to match the wrong node if the suffix is a digital
* while the corresponding node has no name string.
* But we leave this to the graph creator to avoid such case.
*
* @param [in] ir_graph: specific graph.
* @param [in] node_name: reference name.
*
* @return node id.
*/
int get_ir_node_index_from_name(struct graph* ir_graph, const char* node_name);
/*!
* @brief Mark a tensor as node a specific input tensor.
*
* @param [in] ir_node: specific node.
* @param [in] input_idx: input rank in all node input tensors.
* @param [in] tensor: pointer of the tensor.
*
* @return statue value, 0 success, other value failure.
*/
int set_ir_node_input_tensor(ir_node_t* ir_node, int input_idx, struct tensor* tensor);
/*!
* @brief Mark a tensor as node a specific output tensor.
*
* @param [in] node: specific node.
* @param [in] output_idx: output rank in all node output tensors.
* @param [in] tensor: pointer of the tensor.
*
* @return statue value, 0 success, other value failure.
*/
int set_ir_node_output_tensor(ir_node_t* ir_node, int output_idx, struct tensor* tensor);
/*!
* @brief Dump the node.
*
* @param [in] graph: specific graph.
* @param [in] node: specific node.
*/
void dump_ir_node(struct graph* ir_graph, ir_node_t* ir_node);
#ifdef __cplusplus
}
#endif /* __cplusplus */
|
/* @(#)spell.h 1.2 (ULTRIX) 8/13/85 */
/************************************************************************
* *
* Copyright (c) 1985 by *
* Digital Equipment Corporation, Maynard, MA *
* All rights reserved. *
* *
* This software is furnished under a license and may be used and *
* copied only in accordance with the terms of such license and *
* with the inclusion of the above copyright notice. This *
* software or any other copies thereof may not be provided or *
* otherwise made available to any other person. No title to and *
* ownership of the software is hereby transferred. *
* *
* This software is derived from software received from the *
* University of California, Berkeley, and from Bell *
* Laboratories. Use, duplication, or disclosure is subject to *
* restrictions under license agreements with University of *
* California and with AT&T. *
* *
* The information in this software is subject to change without *
* notice and should not be construed as a commitment by Digital *
* Equipment Corporation. *
* *
* Digital assumes no responsibility for the use or reliability *
* of its software on equipment which is not supplied by Digital. *
* *
************************************************************************/
/************************************************************************
*
* Modification History
*
* Stephen Reilly, 13-Aug-85
* Changed the "ri" in fopen to "r" because the "i" option does
* not exist.
*
* @(#)spell.h 4.1 12/18/82
***********************************************************************/
#include <stdio.h>
#include <ctype.h>
#ifndef unix
#define SHIFT 5
#define TABSIZE (int)(400000/(1<<SHIFT))
int *tab; /*honeywell loader deficiency*/
#else
#define Tolower(c) (isupper(c)?tolower(c):c) /* ugh!!! */
#define SHIFT 4
#define TABSIZE 25000 /*(int)(400000/(1<<shift))--pdp11 compiler deficiency*/
short tab[TABSIZE];
#endif
long p[] = {
399871,
399887,
399899,
399911,
399913,
399937,
399941,
399953,
399979,
399983,
399989,
};
#define NP (sizeof(p)/sizeof(p[0]))
#define NW 30
/*
* Hash table for spelling checker has n bits.
* Each word w is hashed by k different (modular) hash functions, hi.
* The bits hi(w), i=1..k, are set for words in the dictionary.
* Assuming independence, the probability that no word of a d-word
* dictionary sets a particular bit is given by the Poisson formula
* P = exp(-y)*y**0/0!, where y=d*k/n.
* The probability that a random string is recognized as a word is then
* (1-P)**k. For given n and d this is minimum when y=log(2), P=1/2,
* whence one finds, for example, that a 25000-word dictionary in a
* 400000-bit table works best with k=11.
*/
long pow2[NP][NW];
prime(argc, argv) register char **argv;
{
int i, j;
long h;
register long *lp;
#ifndef unix
if ((tab = (int *)calloc(sizeof(*tab), TABSIZE)) == NULL)
return(0);
#endif
if (argc > 1) {
FILE *f;
if ((f = fopen(argv[1], "r")) == NULL)
return(0);
if (fread((char *)tab, sizeof(*tab), TABSIZE, f) != TABSIZE)
return(0);
fclose(f);
}
for (i=0; i<NP; i++) {
h = *(lp = pow2[i]) = 1<<14;
for (j=1; j<NW; j++)
h = *++lp = (h<<7) % p[i];
}
return(1);
}
#define get(h) (tab[h>>SHIFT]&(1<<((int)h&((1<<SHIFT)-1))))
#define set(h) tab[h>>SHIFT] |= 1<<((int)h&((1<<SHIFT)-1))
|
#define _PROTECTED_ALL_000100000200030f_H
#ifndef _OZ000100000200030fP_H_
#define _OZ000100000200030fP_H_
#define OZClassPart0001000002fffffd_0_in_000100000200030e 1
#define OZClassPart0001000002fffffe_0_in_000100000200030e 1
#define OZClassPart000100000200030e_0_in_000100000200030e 0
typedef struct OZ000100000200030fPart_Rec {
OZ_AllocateInfoRec alloc_info;
/* protected (pointer) */
OZ_Object ozPreloadingCodes;
OZ_Object ozPreloadingConfiguredClasses;
OZ_Object ozPreloadingLayouts;
OZ_Object ozPreloadingObjects;
OZ_Object ozanExecutor;
int pad0;
/* protected (data) */
/* protected (zero) */
} OZ000100000200030fPart_Rec, *OZ000100000200030fPart;
#ifdef OZ_ObjectPart_Preloader
#undef OZ_ObjectPart_Preloader
#endif
#define OZ_ObjectPart_Preloader OZ000100000200030fPart
#endif _OZ000100000200030fP_H_
#endif _PROTECTED_ALL_000100000200030f_H
|
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : main.c
* @brief : Main program body
******************************************************************************
* @attention
*
* <h2><center>© Copyright (c) 2020 STMicroelectronics.
* All rights reserved.</center></h2>
*
* This software component is licensed by ST under BSD 3-Clause license,
* the "License"; You may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
* opensource.org/licenses/BSD-3-Clause
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "cmsis_os.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "afc_lib/afc_power.h"
#include "afc_lib/afc_barometer.h"
#include "afc_lib/afc_imu.h"
#include "afc_lib/afc_core.h"
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
ADC_HandleTypeDef hadc1;
ADC_HandleTypeDef hadc2;
DMA_HandleTypeDef hdma_adc1;
I2C_HandleTypeDef hi2c1;
QSPI_HandleTypeDef hqspi;
SPI_HandleTypeDef hspi1;
TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim3;
TIM_HandleTypeDef htim9;
UART_HandleTypeDef huart1;
/* Definitions for defaultTask */
osThreadId_t defaultTaskHandle;
const osThreadAttr_t defaultTask_attributes = {
.name = "defaultTask",
.priority = (osPriority_t) osPriorityNormal,
.stack_size = 128 * 4
};
/* USER CODE BEGIN PV */
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_ADC1_Init(void);
static void MX_ADC2_Init(void);
static void MX_I2C1_Init(void);
static void MX_QUADSPI_Init(void);
static void MX_SPI1_Init(void);
static void MX_TIM1_Init(void);
static void MX_TIM3_Init(void);
static void MX_TIM9_Init(void);
static void MX_USART1_UART_Init(void);
void StartDefaultTask(void *argument);
/* USER CODE BEGIN PFP */
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
/* USER CODE END 0 */
/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* MCU Configuration--------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* USER CODE BEGIN Init */
/* USER CODE END Init */
/* Configure the system clock */
SystemClock_Config();
/* USER CODE BEGIN SysInit */
/* USER CODE END SysInit */
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_DMA_Init();
MX_ADC1_Init();
MX_ADC2_Init();
MX_I2C1_Init();
MX_QUADSPI_Init();
MX_SPI1_Init();
MX_TIM1_Init();
MX_TIM3_Init();
MX_TIM9_Init();
MX_USART1_UART_Init();
/* USER CODE BEGIN 2 */
/* USER CODE END 2 */
/* Init scheduler */
osKernelInitialize();
/* USER CODE BEGIN RTOS_MUTEX */
/* add mutexes, ... */
/* USER CODE END RTOS_MUTEX */
/* USER CODE BEGIN RTOS_SEMAPHORES */
/* add semaphores, ... */
/* USER CODE END RTOS_SEMAPHORES */
/* USER CODE BEGIN RTOS_TIMERS */
/* start timers, add new ones, ... */
/* USER CODE END RTOS_TIMERS */
/* USER CODE BEGIN RTOS_QUEUES */
/* add queues, ... */
/* USER CODE END RTOS_QUEUES */
/* Create the thread(s) */
/* creation of defaultTask */
defaultTaskHandle = osThreadNew(StartDefaultTask, NULL, &defaultTask_attributes);
/* USER CODE BEGIN RTOS_THREADS */
afc_pwr_init();
afc_core_init();
/* USER CODE END RTOS_THREADS */
/* USER CODE BEGIN RTOS_EVENTS */
/* add events, ... */
/* USER CODE END RTOS_EVENTS */
/* Start scheduler */
osKernelStart();
/* We should never get here as control is now taken by the scheduler */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
/** Configure the main internal regulator output voltage
*/
__HAL_RCC_PWR_CLK_ENABLE();
__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
/** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
RCC_OscInitStruct.PLL.PLLM = 8;
RCC_OscInitStruct.PLL.PLLN = 180;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 2;
RCC_OscInitStruct.PLL.PLLR = 2;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/** Activate the Over-Drive mode
*/
if (HAL_PWREx_EnableOverDrive() != HAL_OK)
{
Error_Handler();
}
/** Initializes the CPU, AHB and APB buses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)
{
Error_Handler();
}
}
/**
* @brief ADC1 Initialization Function
* @param None
* @retval None
*/
static void MX_ADC1_Init(void)
{
/* USER CODE BEGIN ADC1_Init 0 */
/* USER CODE END ADC1_Init 0 */
ADC_ChannelConfTypeDef sConfig = {0};
/* USER CODE BEGIN ADC1_Init 1 */
/* USER CODE END ADC1_Init 1 */
/** Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
*/
hadc1.Instance = ADC1;
hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
hadc1.Init.Resolution = ADC_RESOLUTION_12B;
hadc1.Init.ScanConvMode = ENABLE;
hadc1.Init.ContinuousConvMode = ENABLE;
hadc1.Init.DiscontinuousConvMode = DISABLE;
hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hadc1.Init.NbrOfConversion = 4;
hadc1.Init.DMAContinuousRequests = ENABLE;
hadc1.Init.EOCSelection = ADC_EOC_SEQ_CONV;
if (HAL_ADC_Init(&hadc1) != HAL_OK)
{
Error_Handler();
}
/** Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.
*/
sConfig.Channel = ADC_CHANNEL_10;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_480CYCLES;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
{
Error_Handler();
}
/** Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.
*/
sConfig.Channel = ADC_CHANNEL_11;
sConfig.Rank = 2;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
{
Error_Handler();
}
/** Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.
*/
sConfig.Channel = ADC_CHANNEL_VBAT;
sConfig.Rank = 3;
sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
{
Error_Handler();
}
/** Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.
*/
sConfig.Channel = ADC_CHANNEL_VREFINT;
sConfig.Rank = 4;
sConfig.SamplingTime = ADC_SAMPLETIME_480CYCLES;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN ADC1_Init 2 */
/* USER CODE END ADC1_Init 2 */
}
/**
* @brief ADC2 Initialization Function
* @param None
* @retval None
*/
static void MX_ADC2_Init(void)
{
/* USER CODE BEGIN ADC2_Init 0 */
/* USER CODE END ADC2_Init 0 */
ADC_ChannelConfTypeDef sConfig = {0};
/* USER CODE BEGIN ADC2_Init 1 */
/* USER CODE END ADC2_Init 1 */
/** Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
*/
hadc2.Instance = ADC2;
hadc2.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
hadc2.Init.Resolution = ADC_RESOLUTION_12B;
hadc2.Init.ScanConvMode = DISABLE;
hadc2.Init.ContinuousConvMode = DISABLE;
hadc2.Init.DiscontinuousConvMode = DISABLE;
hadc2.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
hadc2.Init.ExternalTrigConv = ADC_SOFTWARE_START;
hadc2.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hadc2.Init.NbrOfConversion = 1;
hadc2.Init.DMAContinuousRequests = DISABLE;
hadc2.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
if (HAL_ADC_Init(&hadc2) != HAL_OK)
{
Error_Handler();
}
/** Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.
*/
sConfig.Channel = ADC_CHANNEL_13;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN ADC2_Init 2 */
/* USER CODE END ADC2_Init 2 */
}
/**
* @brief I2C1 Initialization Function
* @param None
* @retval None
*/
static void MX_I2C1_Init(void)
{
/* USER CODE BEGIN I2C1_Init 0 */
/* USER CODE END I2C1_Init 0 */
/* USER CODE BEGIN I2C1_Init 1 */
/* USER CODE END I2C1_Init 1 */
hi2c1.Instance = I2C1;
hi2c1.Init.ClockSpeed = 400000;
hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
hi2c1.Init.OwnAddress1 = 0;
hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
hi2c1.Init.OwnAddress2 = 0;
hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
if (HAL_I2C_Init(&hi2c1) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN I2C1_Init 2 */
/* USER CODE END I2C1_Init 2 */
}
/**
* @brief QUADSPI Initialization Function
* @param None
* @retval None
*/
static void MX_QUADSPI_Init(void)
{
/* USER CODE BEGIN QUADSPI_Init 0 */
/* USER CODE END QUADSPI_Init 0 */
/* USER CODE BEGIN QUADSPI_Init 1 */
/* USER CODE END QUADSPI_Init 1 */
/* QUADSPI parameter configuration*/
hqspi.Instance = QUADSPI;
hqspi.Init.ClockPrescaler = 255;
hqspi.Init.FifoThreshold = 1;
hqspi.Init.SampleShifting = QSPI_SAMPLE_SHIFTING_NONE;
hqspi.Init.FlashSize = 1;
hqspi.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_1_CYCLE;
hqspi.Init.ClockMode = QSPI_CLOCK_MODE_3;
hqspi.Init.FlashID = QSPI_FLASH_ID_2;
hqspi.Init.DualFlash = QSPI_DUALFLASH_DISABLE;
if (HAL_QSPI_Init(&hqspi) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN QUADSPI_Init 2 */
/* USER CODE END QUADSPI_Init 2 */
}
/**
* @brief SPI1 Initialization Function
* @param None
* @retval None
*/
static void MX_SPI1_Init(void)
{
/* USER CODE BEGIN SPI1_Init 0 */
/* USER CODE END SPI1_Init 0 */
/* USER CODE BEGIN SPI1_Init 1 */
/* USER CODE END SPI1_Init 1 */
/* SPI1 parameter configuration*/
hspi1.Instance = SPI1;
hspi1.Init.Mode = SPI_MODE_MASTER;
hspi1.Init.Direction = SPI_DIRECTION_2LINES;
hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
hspi1.Init.NSS = SPI_NSS_SOFT;
hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
hspi1.Init.CRCPolynomial = 10;
if (HAL_SPI_Init(&hspi1) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN SPI1_Init 2 */
/* USER CODE END SPI1_Init 2 */
}
/**
* @brief TIM1 Initialization Function
* @param None
* @retval None
*/
static void MX_TIM1_Init(void)
{
/* USER CODE BEGIN TIM1_Init 0 */
/* USER CODE END TIM1_Init 0 */
TIM_ClockConfigTypeDef sClockSourceConfig = {0};
TIM_MasterConfigTypeDef sMasterConfig = {0};
TIM_OC_InitTypeDef sConfigOC = {0};
TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};
/* USER CODE BEGIN TIM1_Init 1 */
/* USER CODE END TIM1_Init 1 */
htim1.Instance = TIM1;
htim1.Init.Prescaler = 0;
htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
htim1.Init.Period = 65535;
htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim1.Init.RepetitionCounter = 0;
htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
{
Error_Handler();
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_PWM_Init(&htim1) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
{
Error_Handler();
}
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_4) != HAL_OK)
{
Error_Handler();
}
sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
sBreakDeadTimeConfig.DeadTime = 0;
sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN TIM1_Init 2 */
/* USER CODE END TIM1_Init 2 */
HAL_TIM_MspPostInit(&htim1);
}
/**
* @brief TIM3 Initialization Function
* @param None
* @retval None
*/
static void MX_TIM3_Init(void)
{
/* USER CODE BEGIN TIM3_Init 0 */
/* USER CODE END TIM3_Init 0 */
TIM_MasterConfigTypeDef sMasterConfig = {0};
TIM_OC_InitTypeDef sConfigOC = {0};
/* USER CODE BEGIN TIM3_Init 1 */
/* USER CODE END TIM3_Init 1 */
htim3.Instance = TIM3;
htim3.Init.Prescaler = 0;
htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
htim3.Init.Period = 65535;
htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_PWM_Init(&htim3) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
{
Error_Handler();
}
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_4) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN TIM3_Init 2 */
/* USER CODE END TIM3_Init 2 */
HAL_TIM_MspPostInit(&htim3);
}
/**
* @brief TIM9 Initialization Function
* @param None
* @retval None
*/
static void MX_TIM9_Init(void)
{
/* USER CODE BEGIN TIM9_Init 0 */
/* USER CODE END TIM9_Init 0 */
TIM_OC_InitTypeDef sConfigOC = {0};
/* USER CODE BEGIN TIM9_Init 1 */
/* USER CODE END TIM9_Init 1 */
htim9.Instance = TIM9;
htim9.Init.Prescaler = 0;
htim9.Init.CounterMode = TIM_COUNTERMODE_UP;
htim9.Init.Period = 65535;
htim9.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim9.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_PWM_Init(&htim9) != HAL_OK)
{
Error_Handler();
}
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
if (HAL_TIM_PWM_ConfigChannel(&htim9, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_PWM_ConfigChannel(&htim9, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN TIM9_Init 2 */
/* USER CODE END TIM9_Init 2 */
HAL_TIM_MspPostInit(&htim9);
}
/**
* @brief USART1 Initialization Function
* @param None
* @retval None
*/
static void MX_USART1_UART_Init(void)
{
/* USER CODE BEGIN USART1_Init 0 */
/* USER CODE END USART1_Init 0 */
/* USER CODE BEGIN USART1_Init 1 */
/* USER CODE END USART1_Init 1 */
huart1.Instance = USART1;
huart1.Init.BaudRate = 115200;
huart1.Init.WordLength = UART_WORDLENGTH_8B;
huart1.Init.StopBits = UART_STOPBITS_1;
huart1.Init.Parity = UART_PARITY_NONE;
huart1.Init.Mode = UART_MODE_TX_RX;
huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart1.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart1) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN USART1_Init 2 */
/* USER CODE END USART1_Init 2 */
}
/**
* Enable DMA controller clock
*/
static void MX_DMA_Init(void)
{
/* DMA controller clock enable */
__HAL_RCC_DMA2_CLK_ENABLE();
/* DMA interrupt init */
/* DMA2_Stream0_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);
}
/**
* @brief GPIO Initialization Function
* @param None
* @retval None
*/
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOE_CLK_ENABLE();
__HAL_RCC_GPIOH_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOE, LED_RED_Pin|LED_GREEN_Pin|LED_BLUE_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOC, NRF_CS_Pin|NRF_CE_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPS_RST_GPIO_Port, GPS_RST_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOD, PYRO_2_FIRE_Pin|PYRO_1_FIRE_Pin, GPIO_PIN_RESET);
/*Configure GPIO pins : LED_RED_Pin LED_GREEN_Pin LED_BLUE_Pin */
GPIO_InitStruct.Pin = LED_RED_Pin|LED_GREEN_Pin|LED_BLUE_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
/*Configure GPIO pins : NRF_IRQ_Pin GPS_TIMEPULSE_Pin */
GPIO_InitStruct.Pin = NRF_IRQ_Pin|GPS_TIMEPULSE_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/*Configure GPIO pins : NRF_CS_Pin NRF_CE_Pin */
GPIO_InitStruct.Pin = NRF_CS_Pin|NRF_CE_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
/*Configure GPIO pins : PB13 PB14 PB15 */
GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/*Configure GPIO pins : PD8 PD9 */
GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF7_USART3;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
/*Configure GPIO pins : IO4_Pin IO5_Pin IO6_Pin IO7_Pin
IO2_Pin IO3_Pin */
GPIO_InitStruct.Pin = IO4_Pin|IO5_Pin|IO6_Pin|IO7_Pin
|IO2_Pin|IO3_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
/*Configure GPIO pin : PC9 */
GPIO_InitStruct.Pin = GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF4_I2C3;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
/*Configure GPIO pin : PA8 */
GPIO_InitStruct.Pin = GPIO_PIN_8;
GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF4_I2C3;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/*Configure GPIO pin : GPS_RST_Pin */
GPIO_InitStruct.Pin = GPS_RST_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPS_RST_GPIO_Port, &GPIO_InitStruct);
/*Configure GPIO pin : CURR_SENS_FAULT_Pin */
GPIO_InitStruct.Pin = CURR_SENS_FAULT_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(CURR_SENS_FAULT_GPIO_Port, &GPIO_InitStruct);
/*Configure GPIO pin : PD0 */
GPIO_InitStruct.Pin = GPIO_PIN_0;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF9_CAN1;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
/*Configure GPIO pins : PYRO_2_FIRE_Pin PYRO_1_FIRE_Pin */
GPIO_InitStruct.Pin = PYRO_2_FIRE_Pin|PYRO_1_FIRE_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
/*Configure GPIO pin : IMU_INT_Pin */
GPIO_InitStruct.Pin = IMU_INT_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(IMU_INT_GPIO_Port, &GPIO_InitStruct);
}
/* USER CODE BEGIN 4 */
/* USER CODE END 4 */
/* USER CODE BEGIN Header_StartDefaultTask */
/**
* @brief Function implementing the defaultTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartDefaultTask */
void StartDefaultTask(void *argument)
{
/* USER CODE BEGIN 5 */
HAL_StatusTypeDef result = afc_imu_init();
afc_baro_init();
afc_core_set_led_freq(LED_RED, 0);
afc_core_set_led_freq(LED_GREEN, 0);
afc_core_set_led_freq(LED_BLUE, 0);
if (result == HAL_OK) {
afc_core_set_led_freq(LED_GREEN, 500);
} else if(result == HAL_TIMEOUT) {
afc_core_set_led_freq(LED_BLUE, 500);
} else if (result == HAL_ERROR) {
afc_core_set_led_freq(LED_RED, 500);
} else if (result == HAL_BUSY) {
afc_core_set_led_freq(LED_RED, 200);
}
/* Infinite loop */
for(;;)
{
float t = afc_baro_read_temperature();
float p = afc_baro_read_pressure();
osDelay(1000);
}
/* USER CODE END 5 */
}
/**
* @brief Period elapsed callback in non blocking mode
* @note This function is called when TIM14 interrupt took place, inside
* HAL_TIM_IRQHandler(). It makes a direct call to HAL_IncTick() to increment
* a global variable "uwTick" used as application time base.
* @param htim : TIM handle
* @retval None
*/
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
/* USER CODE BEGIN Callback 0 */
/* USER CODE END Callback 0 */
if (htim->Instance == TIM14) {
HAL_IncTick();
}
/* USER CODE BEGIN Callback 1 */
/* USER CODE END Callback 1 */
}
/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
__disable_irq();
while (1)
{
}
/* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @param file: pointer to the source file name
* @param line: assert_param error line source number
* @retval None
*/
void assert_failed(uint8_t *file, uint32_t line)
{
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
#define SIZE 5
struct stack{
int data[SIZE];
int top;
} s;
void push(int item)
{
if(!full()){
s.top++;
s.data[s.top] = item;
}
else printf("Stack is full");
}
int pop()
{
if(!empty()){
int item = s.data[s.top];
s.top--;
return item;
}
else return -999;
}
int full(){
if(s.top==SIZE-1) return 1;
else return 0;
}
int empty(){
if(s.top==-1) return 1;
else return 0;
}
int peek(){
if(!empty()){
return s.data[s.top];
else return -999;
}
|
#include <stdio.h>
#include "heap.h"
#include "dll.h"
void printTree(tree *t) {
if (t) {
printf("<");
printTree(t->l);
printf(" %d ", t->x);
printTree(t->r);
printf(">");
}
}
void main() {
int items[] = {4,-2,5,92,-5,-2,8};
tree *heap = heapify(items, sizeof(items) / sizeof(items[0]));
printTree(heap);
printf("\n");
xorCell *c = fromArray(items, sizeof(items) / sizeof(items[0]));
xorCell *d = insert(6, NULL, c);
printXorList(d);
}
|
/* See LICENSE file for copyright and license details. */
/* appearance */
static const unsigned int borderpx = 0; /* border pixel of windows */
static const unsigned int snap = 8; /* snap pixel */
static const unsigned int gappih = 3; /* horiz inner gap between windows */
static const unsigned int gappiv = 3; /* vert inner gap between windows */
static const unsigned int gappoh = 3; /* horiz outer gap between windows and screen edge */
static const unsigned int gappov = 3; /* vert outer gap between windows and screen edge */
static const int smartgaps = 0; /* 1 means no outer gap when there is only one window */
static const int showbar = 1; /* 0 means no bar */
static const int topbar = 1; /* 0 means bottom bar */
static const int user_bh = 1; /* 2 is the default spacing around the bar's font */
static const int vertpad = 4; /* vertical padding of bar */
static const int sidepad = 10; /* horizontal padding of bar */
static const char *fonts[] = {"terminus:style=Bold:size=14"};
static const char dmenufont[] = "terminus:style=Bold:size=18";
static const char col_gray1[] = "#ffffff";
static const char col_gray2[] = "#444444";
static const char col_gray3[] = "#f91010";
static const char col_gray4[] = "#140b05";
static const char col_cyan[] = "#fc9505";
static const unsigned int baralpha = 0xd0;
static const unsigned int borderalpha = OPAQUE;
static const char *colors[][3] = {
/* fg bg border */
[SchemeNorm] = {col_gray3, col_gray1, col_gray2},
[SchemeSel] = {col_gray4, col_cyan, col_cyan},
};
static const unsigned int alphas[][3] = {
/* fg bg border */
[SchemeNorm] = { OPAQUE, baralpha, borderalpha },
[SchemeSel] = { OPAQUE, baralpha, borderalpha },
};
/* tagging */
static const char *tags[] = {"", "", "", "", "", "", "", "", ""};
static const char *alttags[] = {"", "", "", "", "", "", "", "", ""};
static const unsigned int ulinepad = 4; /* horizontal padding between the underline and tag */
static const unsigned int ulinestroke = 0; /* thickness / height of the underline */
static const unsigned int ulinevoffset = 0; /* how far above the bottom of the bar the line should appear */
static const int ulineall = 0; /* 1 to show underline on all tags, 0 for just the active ones */
static const Rule rules[] = {
/* xprop(1):
* WM_CLASS(STRING) = instance, class
* WM_NAME(STRING) = title
*/
/* class instance title tagsMask isfloating isterminal noswallow monitor
*/
{"obs", NULL, NULL, 1 << 7, False, 0, 0, -1},
{"Surf", NULL, NULL, 1 << 3, False, 0, 0, -1},
{"Virt-manager", NULL, NULL, 1 << 8, False, 0, -1, -1},
{"Chromium", NULL, NULL, 1 << 1, False, 0, -1, -1},
{"Transmission-gtk", NULL, NULL, 1 << 5, False, 0, -1, -1},
{"Gimp", NULL, NULL, 1 << 3, False, 0, -1, -1},
{"st", NULL, "ranger", 1 << 6, False, 0, -1, -1},
{"st", NULL, "ncmpcpp", 1 << 6, False, 0, -1, -1},
{"st", NULL, "htop", 1 << 5, False, 0, -1, -1},
{"qutebrowser", NULL, NULL, 1 << 3, False, 0, -1, -1},
{"st", NULL, NULL, 0, 0, 1, 1, -1},
{"Alacritty", NULL, NULL, 0, 0, 1, 1, -1},
{NULL, NULL, "Event Tester", 0, 0, 0, 1, -1}, /* xev */
};
/* layout(s) */
static const float mfact = 0.60; /* factor of master area size [0.05..0.95] */
static const int nmaster = 1; /* number of clients in master area */
static const int resizehints = 1; /* 1 means respect size hints in tiled resizals */
static const int lockfullscreen = 1; /* 1 will force focus on the fullscreen window */
static const Layout layouts[] = {
/* symbol arrange function */
{"[]=", tile}, /* first entry is default */
{"><>", NULL}, /* no layout function means floating behavior */
{"[M]", monocle},
};
/* volume control */
/*
#define XF86AudioLowerVolume 0x1008ff11
#define XF86AudioMute 0x1008ff12
#define XF86AudioRaiseVolume 0x1008ff13
*/
/* key definitions */
#define MODKEY Mod1Mask
#define TAGKEYS(KEY, TAG) \
{MODKEY, KEY, view, {.ui = 1 << TAG}}, \
{MODKEY | ControlMask, KEY, toggleview, {.ui = 1 << TAG}}, \
{MODKEY | ShiftMask, KEY, tag, {.ui = 1 << TAG}}, \
{MODKEY | ControlMask | ShiftMask, KEY, toggletag, {.ui = 1 << TAG}},
/* helper for spawning shell commands in the pre dwm-5.0 fashion */
#define SHCMD(cmd) \
{ \
.v = (const char *[]) { "/bin/sh", "-c", cmd, NULL } \
}
/* commands */
static char dmenumon[2] = "0"; /* component of dmenucmd, manipulated in spawn() */
static const char *dmenucmd[] = { "dmenu_run", NULL };
static const char *termcmd[] = { "st", NULL };
static const char *clipcmd[] = { "clipmenu", NULL };
static const char *hcmd[] = { "st", "-e", "htop", "-t", NULL };
static const char *rancmd[] = { "st", "-e", "ranger", NULL };
static const char *lockcmd[] = { "slock", NULL };
static const char *screcmd[] = { "scrot", "/home/sh/Images/shots/shot-%Y-%m-%d-%H-%M-%S.jpg", NULL };
static const char *virtcmd[] = { "virt-manager", NULL };
static const char *chrocmd[] = { "chromium", NULL };
static const char *boatcmd[] = { "st", "-e", "newsboat", NULL };
static const char *ytcmd[] = { "ytfzf", "-D", NULL };
static const char *ytdcmd[] = { "ytfzf", "-d", "-D", NULL };
static const char *flamcmd[] = { "flameshot", "gui", NULL };
static const char *up[] = { "amixer", "set", "Master", "10%+", NULL };
static const char *mut[] = { "amixer", "set", "Master", "toggle", NULL };
static const char *down[] = { "amixer", "set", "Master", "10%-", NULL };
static const char scratchpadname[] = "scratchpad";
static const char *scratchpadcmd[] = { "st", "-t", scratchpadname, "-g", "108x30", NULL };
static const char *alcmd[] = { "alacritty", NULL };
static const char *searchcmd[] = { "search", NULL };
static const char *dowcmd[] = { "dow", NULL };
static Key keys[] = {
/* modifier key function argument */
{MODKEY, XK_a, spawn, {.v = alcmd}},
{MODKEY, XK_x, spawn, {.v = dowcmd}},
{MODKEY, XK_y, spawn, {.v = ytcmd}},
{MODKEY, XK_d, spawn, {.v = ytdcmd}},
{MODKEY, XK_f, spawn, {.v = searchcmd}},
{MODKEY | ShiftMask, XK_f, spawn, {.v = flamcmd}},
{MODKEY, XK_s, togglescratch, {.v = scratchpadcmd}},
{MODKEY | ShiftMask, XK_n, spawn, {.v = boatcmd}},
{MODKEY | ShiftMask, XK_l, spawn, {.v = lockcmd}},
{MODKEY | ShiftMask, XK_s, spawn, {.v = screcmd}},
{MODKEY, XK_w, spawn, {.v = chrocmd}},
{MODKEY, XK_v, spawn, {.v = virtcmd}},
{MODKEY, XK_r, spawn, {.v = rancmd}},
{MODKEY, XK_e, spawn, {.v = hcmd}},
{MODKEY, XK_p, spawn, {.v = dmenucmd}},
{MODKEY | ShiftMask, XK_Return, spawn, {.v = termcmd}},
{MODKEY, XK_n, spawn, {.v = clipcmd}},
{MODKEY, XK_b, togglebar, {0}},
{MODKEY, XK_k, focusstack, {.i = +1}},
{MODKEY, XK_l, focusstack, {.i = -1}},
{MODKEY, XK_i, incnmaster, {.i = +1}},
{MODKEY, XK_o, incnmaster, {.i = -1}},
{MODKEY, XK_j, setmfact, {.f = -0.03}},
{MODKEY, XK_m, setmfact, {.f = +0.03}},
{MODKEY | Mod4Mask, XK_h, incrgaps, {.i = +1}},
{MODKEY | Mod4Mask, XK_l, incrgaps, {.i = -1}},
{MODKEY | Mod4Mask | ShiftMask, XK_h, incrogaps, {.i = +1}},
{MODKEY | Mod4Mask | ShiftMask, XK_l, incrogaps, {.i = -1}},
{MODKEY | Mod4Mask | ControlMask, XK_h, incrigaps, {.i = +1}},
{MODKEY | Mod4Mask | ControlMask, XK_l, incrigaps, {.i = -1}},
{MODKEY | Mod4Mask, XK_0, togglegaps, {0}},
{MODKEY | Mod4Mask | ShiftMask, XK_0, defaultgaps, {0}},
{MODKEY | ShiftMask | ControlMask, XK_y, incrihgaps, {.i = +1}},
{MODKEY | ControlMask, XK_o, incrihgaps, {.i = -1}},
{MODKEY | ControlMask, XK_y, incrivgaps, {.i = +1}},
{MODKEY | ControlMask, XK_o, incrivgaps, {.i = -1}},
{MODKEY | Mod4Mask, XK_y, incrohgaps, {.i = +1}},
{MODKEY | Mod4Mask, XK_o, incrohgaps, {.i = -1}},
{MODKEY | ControlMask | ShiftMask, XK_y, incrovgaps, {.i = +1}},
{MODKEY | ShiftMask | ControlMask, XK_o, incrovgaps, {.i = -1}},
{MODKEY, XK_Return, zoom, {0}},
{MODKEY, XK_Tab, view, {0}},
{MODKEY | ShiftMask, XK_c, killclient, {0}},
{MODKEY | ShiftMask, XK_t, setlayout, {.v = &layouts[0]}},
{MODKEY | ShiftMask, XK_y, setlayout, {.v = &layouts[1]}},
{MODKEY | ShiftMask, XK_u, setlayout, {.v = &layouts[2]}},
{MODKEY, XK_space, setlayout, {0}},
{MODKEY | ShiftMask, XK_space, togglefloating, {0}},
{MODKEY | ShiftMask, XK_x, view, {.ui = ~0}},
{MODKEY | ShiftMask, XK_z, tag, {.ui = ~0}},
{MODKEY, XK_comma, focusmon, {.i = -1}},
{MODKEY, XK_semicolon, focusmon, {.i = +1}},
{MODKEY | ShiftMask, XK_comma, tagmon, {.i = -1}},
{MODKEY | ShiftMask, XK_semicolon, tagmon, {.i = +1}},
{0, XK_F3, spawn, {.v = up}},
{0, XK_F2, spawn, {.v = down}},
{0, XK_F4, spawn, {.v = mut}},
{MODKEY | ShiftMask, XK_q, quit, {0}},
TAGKEYS( XK_ampersand, 0)
TAGKEYS( XK_eacute, 1)
TAGKEYS( XK_quotedbl, 2)
TAGKEYS( XK_apostrophe, 3)
TAGKEYS( XK_parenleft, 4)
TAGKEYS( XK_minus, 5)
TAGKEYS( XK_egrave, 6)
TAGKEYS( XK_underscore, 7)
TAGKEYS( XK_ccedilla, 8)
};
/* button definitions */
/* click can be ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle,
* ClkClientWin, or ClkRootWin */
static Button buttons[] = {
/* click event mask button function argument */
{ClkLtSymbol, 0, Button1, setlayout, {0}},
{ClkLtSymbol, 0, Button3, setlayout, {.v = &layouts[2]}},
{ClkStatusText, 0, Button2, spawn, {.v = termcmd}},
{ClkClientWin, MODKEY, Button1, movemouse, {0}},
{ClkClientWin, MODKEY, Button2, togglefloating, {0}},
{ClkClientWin, MODKEY, Button3, resizemouse, {0}},
{ClkTagBar, 0, Button1, view, {0}},
{ClkTagBar, 0, Button3, toggleview, {0}},
{ClkTagBar, MODKEY, Button1, tag, {0}},
{ClkTagBar, MODKEY, Button3, toggletag, {0}},
};
|
# ifndef _AVOIDOBSTACLE_H_
# define _AVOIDOBSTACLE_H_
# define Ultrasound_Uart_Port LPUART6
typedef enum
{
Meassuring,
Meassured,
Error
}Enum_UltrasoundMeassure;
extern Enum_UltrasoundMeassure UltrasoundMeassure;
# define MaxMeassureRangeSetCMD_50cm 0x05 // 3885us
# define MaxMeassureRangeSetCMD_100cm 0x0A // 6770us
# define MaxMeassureRangeSetCMD_150cm 0x0F // 9655us
# define MaxMeassureRangeSetCMD_200cm 0x14 // 12540us
void ReceiveDistance();
void SendCMDToUltrasound();
void UltrasoundInit();
extern float Distance_Meassured;//µ¥Î»cm
# endif
|
/*
** EPITECH PROJECT, 2020
** MY_RPG
** File description:
** .h for sm1_init.c
*/
#ifndef MY_PLAYER_MOVEMENT_H_
#define MY_PLAYER_MOVEMENT_H_
#include "../include_all.h"
#include "main.h"
void player_move(main_t *main_struct);
int check_cols_right(main_t *main_struct);
int check_cols_left(main_t *main_struct);
int check_cols_down(main_t *main_struct);
int check_cols_up(main_t *main_struct);
char **get_collision(char *filename);
void go_left(main_t *main_struct);
void go_up(main_t *main_struct);
void go_right(main_t *main_struct);
void go_down(main_t *main_struct);
void change_map_3(main_t *main_struct);
#endif //MY_PLAYER_MOVEMENT_H_
|
#include <std.h>
#include <amun.h>
inherit WEAPON;
int weapon_hit();
create() {
::create();
set_name("Pumpkin");
set("id", ({ "pumpkin" }) );
set("short", "%^RESET%^%^ORANGE%^Pum%^BOLD%^%^BLACK%^p%^RESET%^%^ORANGE%^kin%^RESET%^");
set("long", "%^RESET%^%^ORANGE%^This pumpkin is lit with fire. The Headless horeseman will surely want it back some day." );
set_type("projectile");
set_weight(10);
set_curr_value("gold", 200);
set_wc(8);
set_type("projectile");
set("skill level", 115);
set_wield("%^BOLD%^%^BLACK%^The %^RESET%^%^ORANGE%^Pum%^BOLD%^%^BLACK%^p%^RESET%^%^ORANGE%^kin %^BOLD%^%^BLACK%^cackles as you wield it.%^RESET%^");
set_unwield("%^BOLD%^%^BLACK%^The %^RESET%^%^ORANGE%^Pum%^BOLD%^%^BLACK%^p%^RESET%^%^ORANGE%^kin %^BOLD%^%^BLACK%^stops cackling as you release it.%^RESET%^");
set_hit((:this_object(),"weapon_hit":));
}
int weapon_hit() {
int result;
object atk;
atk = (object)this_player()->query_current_attacker();
if(random(100) > 90) {
write("%^BOLD%^%^BLACK%^You throw the %^RESET%^%^ORANGE%^Pum%^BOLD%^%^BLACK%^p%^RESET%^%^ORANGE%^kin %^BOLD%^%^BLACK%^into "+ atk->query_cap_name() +"'s face, setting them on %^RED%^fire%^BLACK%^!%^RESET%^");
say((string)this_player()->query_cap_name() + " %^BOLD%^%^BLACK%^throws the %^RESET%^%^ORANGE%^Pum%^BOLD%^%^BLACK%^p%^RESET%^%^ORANGE%^kin %^BOLD%^%^BLACK%^into " + atk->query_cap_name() + "'s face setting them on %^RED%^fire%^BLACK%^!%^RESET%^");
result=(random(50))+((this_player()->query_level())*2/3);
if(random(100) > 74) {
write("%^BOLD%^%^BLACK%^You notice the %^RESET%^%^ORANGE%^Pum%^BOLD%^%^BLACK%^p%^RESET%^%^ORANGE%^kin %^BOLD%^%^BLACK%^jumps to life and lunges at "+ atk->query_cap_name() +"'s causing them to %^RED%^engulf in flames%^BLACK%^!%^RESET%^");
say((string)this_player()->query_cap_name() + " %^BOLD%^%^BLACK%^notices the %^RESET%^%^ORANGE%^Pum%^BOLD%^%^BLACK%^p%^RESET%^%^ORANGE%^kin %^BOLD%^%^BLACK%^jump to life and lunge at " + atk->query_cap_name() + " causing them to %^RED%^engulf in flames%^BLACK%^!%^RESET%^");
atk->set_paralyzed(random(2));
return result;
}
}
}
int query_auto_load() {
if (this_player()->query_level() >= 36)
return 1;
}
|
#include "client.h"
int main(int argc, char **argv) {
/* 格式：./client -ip set_ip(点分格式，例如127.0.0.1) -port set_port */
for (int i = 1; i < argc; i++) {
if (strcmp(argv[i], "-ip") == 0 && argv[i+1] && strcmp(argv[i+1], "-port") != 0) {
memset(set_ip, 0, 20);
strcpy(set_ip, argv[i+1]);
}
else if (strcmp(argv[i], "-port") == 0 && argv[i+1] && strcmp(argv[i+1], "-ip") != 0) {
set_port = atoi(argv[i+1]);
}
}
int sockfd;
struct sockaddr_in addr;
char sentence[MAXSIZE];
if ((sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
printf("Error socket(): %s(%d)\n", strerror(errno), errno);
return 1;
}
// 助教服务器: 166.111.80.127
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(set_port); //127.0.0.1
if (inet_pton(AF_INET, set_ip, &addr.sin_addr) <= 0) {
printf("Error inet_pton(): %s(%d)\n", strerror(errno), errno);
return 1;
}
printf("connecting...\n");
if (connect(sockfd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
printf("Error connect(): %s(%d)\n", strerror(errno), errno);
return 1;
}
clientOperation(sockfd, sentence);
closeAllSocket();
return 0;
}
int clientOperation(int sockfd, char *sentence) {
char cmd[MAXSIZE];
ClientRecv(sockfd, sentence);
if (judgeSubStr(sentence, "220") == 0) {
printf("fail to connect.\n");
closeAllSocket();
exit(1);
}
printf("%s", sentence);
UserLogin(sockfd, sentence);
while(1){
multireceive = -1;
readFtpCmd(sentence);
memset(cmd, 0, MAXSIZE);
strcpy(cmd, sentence);
if (judgeSubStr(sentence, "LIST")) {
char str[10] = "PASV";
for (int i = 0; i < 4; i++) {
sentence[i] = str[i];
}
}
if (ClientSend(sockfd, sentence) < 0) {
closeAllSocket();
exit(1);
}
if (ClientRecv(sockfd, sentence) < 0) {
closeAllSocket();
exit(1);
}
printf("%s", sentence);
/* 判是否接收了多条server消息 */
for (unsigned int i = 0; i < strlen(sentence); i++) {
if (sentence[i] == '\r' || sentence[i] == '\n') {
multireceive++;
if (sentence[i+1] == '\r' || sentence[i+1] == '\n') {
i++;
}
}
}
if (judgeSubStr(sentence, "200") && judgeSubStr(cmd, "PORT")) {
if (client_PORT(cmd) < 0) {
printf("Error opening socket for data connection\r\n");
}
else {
mode = MPORT;
}
}
else if (judgeSubStr(sentence, "227") && judgeSubStr(cmd, "PASV")) {
if (client_PASV(sockfd, sentence) < 0) {
printf("Error opening socket for data connection\r\n");
}
else {
mode = MPASV;
}
}
else if (judgeSubStr(sentence, "150") && judgeSubStr(cmd, "RETR")) {
if (client_RETR(cmd) < 0) {
printf("Error download file\r\n");
}
if (multireceive == 0) {
if (ClientRecv(sockfd, sentence) < 0) {
closeAllSocket();
exit(1);
}
printf("%s", sentence);
}
mode = MDEFAULT;
}
else if (judgeSubStr(sentence, "150") && judgeSubStr(cmd, "STOR")) {
if (client_STOR(cmd) < 0) {
printf("Error upload file\r\n");
}
if (multireceive == 0) {
if (ClientRecv(sockfd, sentence) < 0) {
closeAllSocket();
exit(1);
}
printf("%s", sentence);
}
mode = MDEFAULT;
}
else if (judgeSubStr(sentence, "257") && judgeSubStr(cmd, "MKD")) {
if (client_MKD(sockfd, cmd) < 0) {
printf("fail to create directory\n");
}
}
else if (judgeSubStr(sentence, "227") && judgeSubStr(cmd, "LIST")) {
if (client_LIST(sockfd, cmd, sentence) < 0) {
printf("fail to get list.\n");
}
if (multireceive == 0) {
if (ClientRecv(sockfd, sentence) < 0) {
closeAllSocket();
exit(1);
}
printf("%s", sentence);
}
}
else if (judgeSubStr(sentence, "221") && judgeSubStr(cmd, "QUIT")) {
break;
}
else if (judgeSubStr(sentence, "221") && judgeSubStr(cmd, "ABOR")) {
break;
}
}
return 0;
}
void UserLogin(int sockfd, char *sentence) {
/* 输入用户名循环 */
while(1) {
readCommand(sentence);
ClientSend(sockfd, sentence);
ClientRecv(sockfd, sentence);
printf("%s", sentence);
if (judgeSubStr(sentence, "331")) {
break;
}
}
/* 输入密码循环 */
while(1) {
readCommand(sentence);
ClientSend(sockfd, sentence);
ClientRecv(sockfd, sentence);
printf("%s", sentence);
if (judgeSubStr(sentence, "230")) {
break;
}
}
}
void closeAllSocket() {
if (client_data_socket > 0) {
close(client_data_socket);
client_data_socket = -1;
}
if (client_pasv_socket > 0) {
close(client_pasv_socket);
client_pasv_socket = -1;
}
if (client_listen_port_socket > 0) {
close(client_listen_port_socket);
client_listen_port_socket = -1;
}
close(sockfd);
}
void readCommand(char *sentence) {
memset(sentence, 0, MAXSIZE);
fgets(sentence,4096,stdin);
//int len = strlen(sentence);
//sentence[len - 1] = '\0';
return;
}
void readFtpCmd(char *sentence) {
printf("ftp> ");
readCommand(sentence);
return;
}
int ClientSend(int sockfd, const char *sentence) {
if (write(sockfd, sentence, strlen(sentence)) < 0) {
printf("Error write(): %s(%d)\n", strerror(errno), errno);
return -1;
}
return 0;
}
int ClientRecv(int sockfd, char *sentence) {
memset(sentence, 0, MAXSIZE);
int len = 0;
if ((len = read(sockfd, sentence, MAXSIZE)) < 0) {
printf("Error read(): %s(%d)\n", strerror(errno), errno);
return -1;
}
return len;
}
int judgeSubStr(char *source, const char *target) {
int flag = 1;
for (unsigned int i = 0; i < strlen(target); i++) {
if (source[i] != target[i]) {
flag = 0;
}
}
return flag;
}
void parseCommand(char *sentence, int len, char *cmd) {
unsigned int index = len;
while (sentence[index] == ' ' && index < strlen(sentence)) {
index++;
}
if (index == strlen(sentence)) {
printf("command is invalid.\r\n");
return;
}
int i = 0;
for (; index < strlen(sentence); index++) {
cmd[i] = sentence[index];
i++;
}
cmd[i] = '\0';
}
void parseIpPort(char *sentence, int len, char *ip, int *port) {
int digit = 0;
unsigned int index = len;
int symbol = 0;
for (int i = 0; index < strlen(sentence); index++) {
if (sentence[index] >= '0' && sentence[index] <= '9') {
ip[i++] = sentence[index];
digit = digit * 10 + (sentence[index] - '0');
}
else if (sentence[index] == ','){
symbol++;
if (symbol == 4) {
ip[i++] = '\0';
break;
}
ip[i++] = '.';
if (digit < 0 || digit > 255) {
printf("ip address is invalid.\r\n");
return;
}
digit = 0;
}
}
digit = 0;
for (; index < strlen(sentence); index++) {
if (sentence[index] >= '0' && sentence[index] <= '9') {
*port = *port * 10 + (sentence[index] - '0');
}
else if (sentence[index] == ','){
digit = *port;
*port = 0;
}
}
*port += digit * 256;
}
int client_PASV(int sockfd, char *sentence) {
char ip[20];
int port = 0;
int index = 0;
/* 客户端解析获取ip和port */
sentence[strlen(sentence) - 1] = '\0';
while (sentence[index] != '(') {
index++;
}
parseIpPort(sentence, index + 1, ip, &port);
memset(&pasvaddr, 0, sizeof(pasvaddr));
/* 本地建立socket */
pasvaddr.sin_family = AF_INET;
pasvaddr.sin_port = htons(port);
if (inet_pton(AF_INET, ip, &pasvaddr.sin_addr) <= 0) {
printf("Error inet_pton(): %s(%d)\n", strerror(errno), errno);
return -1;
}
/* 若client的PASV处于打开状态，则关闭 */
if (client_pasv_socket >= 0) {
close(client_pasv_socket);
client_pasv_socket = -1;
}
if ((client_pasv_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
printf("Error socket(): %s(%d)\n", strerror(errno), errno);
return -1;
}
if (clientConnect() < 0) {
printf("Error connect(): %s(%d)\n", strerror(errno), errno);
close(client_pasv_socket);
client_pasv_socket = -1;
return -1;
}
return 0;
}
int client_PORT(char *sentence) {
char ip[20];
int port = 0;
struct sockaddr_in portaddr;
parseIpPort(sentence, 5, ip, &port);
/* PORT模式建立socket并设立监听 */
memset(&portaddr, 0, sizeof(portaddr));
portaddr.sin_family = AF_INET;
portaddr.sin_port = htons(port);
if (inet_pton(AF_INET, ip, &portaddr.sin_addr) <= 0) {
printf("Error inet_pton(): %s(%d)\n", strerror(errno), errno);
return -1;
}
/* 若client的PORT模式处于打开状态，则关闭 */
if (client_listen_port_socket >= 0) {
close(client_listen_port_socket);
client_listen_port_socket = -1;
}
if ((client_listen_port_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
printf("Error socket(): %s(%d)\n", strerror(errno), errno);
return -1;
}
if (bind(client_listen_port_socket, (struct sockaddr*)&portaddr, sizeof(portaddr)) == -1) {
printf("Error bind(): %s(%d)\n", strerror(errno), errno);
if (client_listen_port_socket >= 0) {
close(client_listen_port_socket);
client_listen_port_socket = -1;
}
return -1;
}
if (listen(client_listen_port_socket, 10) == -1) {
printf("Error listen(): %s(%d)\n", strerror(errno), errno);
if (client_listen_port_socket >= 0) {
close(client_listen_port_socket);
client_listen_port_socket = -1;
}
return -1;
}
return 0;
}
int clientConnect() {
if (connect(client_pasv_socket, (struct sockaddr*)&pasvaddr, sizeof(pasvaddr)) < 0) {
printf("Error connect(): %s(%d)\n", strerror(errno), errno);
if (client_pasv_socket >= 0) {
close(client_pasv_socket);
client_pasv_socket = -1;
}
return -1;
}
return 0;
}
int clientAccept() {
if (client_data_socket >= 0) {
close(client_data_socket);
client_data_socket = -1;
}
if ((client_data_socket = accept(client_listen_port_socket, NULL, NULL)) == -1) {
printf("Error accept(): %s(%d)\n", strerror(errno), errno);
return -1;
}
return 0;
}
int clientReceiveFile(int sock, char *sentence) {
char filepath[MAXFILEPATH];
parseCommand(sentence, 4, filepath);
for (unsigned int i = 0; i < strlen(filepath); i++) {
if (filepath[i] == '\r' || filepath[i] == '\n') {
filepath[i] = '\0';
break;
}
}
FILE *dataFile = fopen(filepath, "wb");
if (!dataFile) {
ClientSend(sockfd, "No such file or dictionary.");
return -1;
}
else {
int datasize = 0;
while (1) {
datasize = ClientRecv(sock, sentence);
if (datasize > 0) {
fwrite(sentence, 1, datasize, dataFile);
}
else if (datasize == 0) {
break;
}
else {
fclose(dataFile);
return -1;
}
}
}
fclose(dataFile);
return 0;
}
int clientTransferFile(int sock, char *sentence) {
char filepath[MAXFILEPATH];
parseCommand(sentence, 4, filepath);
for (unsigned int i = 0; i < strlen(filepath); i++) {
if (filepath[i] == '\r' || filepath[i] == '\n') {
filepath[i] = '\0';
break;
}
}
FILE *dataFile = fopen(filepath, "rb");
if (!dataFile) {
printf("%s", "No such file or dictionary.\r\n");
return -1;
}
else {
int datasize = 0;
memset(sentence, 0, MAXSIZE);
do {
if ((datasize = fread(sentence, 1, MAXSIZE, dataFile)) < 0) {
printf("%s", "Error when reading the file.\r\n");
close(sock);
sock = -1;
if (mode == MPORT) {
close(client_listen_port_socket);
client_listen_port_socket = -1;
}
return -1;
}
else if (datasize == 0) {
break;
}
if (write(sock, sentence, datasize) < 0) {
printf("%s", "connection was broken or network failure.\r\n");
close(sock);
sock = -1;
if (mode == MPORT) {
close(client_listen_port_socket);
client_listen_port_socket = -1;
}
return -1;
}
} while (datasize > 0);
}
fclose(dataFile);
return 0;
}
int client_RETR(char *sentence) {
if (mode == MPORT) {
if (clientAccept() < 0) {
printf("Error accept(): %s(%d)\n", strerror(errno), errno);
close(client_data_socket);
client_data_socket = -1;
close(client_listen_port_socket);
client_listen_port_socket = -1;
return -1;
}
if (clientReceiveFile(client_data_socket, sentence) < 0) {
return -1;
}
close(client_data_socket);
client_data_socket = -1;
close(client_listen_port_socket);
client_listen_port_socket = -1;
}
else if (mode == MPASV) {
if (clientReceiveFile(client_pasv_socket, sentence) < 0) {
return -1;
}
close(client_pasv_socket);
client_pasv_socket = -1;
}
return 0;
}
int client_STOR(char *sentence) {
if (mode == MPORT) {
if (clientAccept() < 0) {
printf("Error accept(): %s(%d)\n", strerror(errno), errno);
close(client_data_socket);
client_data_socket = -1;
close(client_listen_port_socket);
client_listen_port_socket = -1;
return -1;
}
if (clientTransferFile(client_data_socket, sentence) < 0) {
close(client_data_socket);
client_data_socket = -1;
close(client_listen_port_socket);
client_listen_port_socket = -1;
return -1;
}
close(client_data_socket);
client_data_socket = -1;
close(client_listen_port_socket);
client_listen_port_socket = -1;
}
else if (mode == MPASV) {
if (clientTransferFile(client_pasv_socket, sentence) < 0) {
close(client_pasv_socket);
client_pasv_socket = -1;
return -1;
}
close(client_pasv_socket);
client_pasv_socket = -1;
}
return 0;
}
int client_LIST(int sockfd, char *cmd, char *sentence) {
if (client_PASV(sockfd, sentence) < 0) {
printf("Error opening socket for data connection\r\n");
return -1;
}
ClientSend(sockfd, cmd);
ClientRecv(sockfd, sentence);
printf("%s", sentence);
/* 判是否接收了多条server消息 */
multireceive = -1;
for (unsigned int i = 0; i < strlen(sentence); i++) {
if (sentence[i] == '\r' || sentence[i] == '\n') {
multireceive++;
if (sentence[i+1] == '\r' || sentence[i+1] == '\n') {
i++;
}
}
}
while (ClientRecv(client_pasv_socket, sentence) > 0) {
printf("%s", sentence);
}
close(client_pasv_socket);
client_pasv_socket = -1;
return 0;
}
int client_MKD(int sockfd, char *sentence) {
//////ClientRecv(sockfd, sentence);
//////printf("%s", sentence);
return 0;
}
int client_PWD(int sockfd, char *sentence) {
return 0;
}
int client_RMD(int sockfd, char *sentence) {
return 0;
}
int client_CWD(int sockfd, char *sentence) {
return 0;
}
|
/*
****************************************************************
* *
* bits.c *
* *
* Output variable-length bit strings *
* *
* Versão 3.0.0, de 05.06.93 *
* 3.0.0, de 09.06.93 *
* *
* Módulo: GZIP *
* Utilitários de compressão/descompressão *
* Categoria B *
* *
* TROPIX: Sistema Operacional Tempo-Real Multiprocessado *
* Copyright © 2000 NCE/UFRJ - tecle "man licença" *
* Baseado em software homônimo do GNU *
* *
****************************************************************
*/
#include <sys/types.h>
#include <stdio.h>
#include "../h/gzip.h"
/*
****************************************************************
* Variáveis globais *
****************************************************************
*/
local file_t zfile; /* output gzip file */
/*
* Output buffer. bits are inserted starting at the bottom
* (least significant bits).
*/
local unsigned short bi_buf;
/*
* Number of bits used within bi_buf. (bi_buf might be implemented on
* more than 16 bits on some systems.)
*/
#define Buf_size (8 * 2 * sizeof (char))
/*
* Number of valid bits in bi_buf. All bits above the last valid bit
* are always zero.
*/
local int bi_valid;
/*
****** Tabela de inversão de um byte ***************************
*/
const char inv_byte[256] =
{
/* 0 1 2 3 4 5 6 7 */
/* 8 9 A B C D E F */
/* 0.*/ 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
/* 1.*/ 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
/* 2.*/ 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
/* 3.*/ 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
/* 4.*/ 0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
/* 5.*/ 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
/* 6.*/ 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
/* 7.*/ 0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
/* 8.*/ 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
/* 9.*/ 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
/* A.*/ 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
/* B.*/ 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
/* C.*/ 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
/* D.*/ 0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
/* E.*/ 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
/* F.*/ 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
};
/*
****** Saída ZIP ***********************************************
*/
extern ZIPFILE zipfile; /* Estrutura para a saída ZIP */
/*
****************************************************************
* Initialize the bit string routines *
****************************************************************
*/
void
bi_init (file_t zp)
{
zfile = zp;
bi_buf = 0;
bi_valid = 0;
} /* end bi_init */
/*
****************************************************************
* Send a value on a given number of bits *
****************************************************************
*/
void
send_bits (register unsigned value, register int length)
{
register ZIPFILE *zp1 = &zipfile;
register ulong u;
/*
* If not enough room in bi_buf, use (valid) bits
* from bi_buf and (16 - bi_valid) bits from value,
* leaving (width - (16-bi_valid)) unused bits in value.
*/
if (bi_valid > Buf_size - length)
{
u = bi_buf | (value << bi_valid);
PUTZIP (u); PUTZIP (u >> 8);
bi_buf = value >> (Buf_size - bi_valid);
bi_valid += length - Buf_size;
}
else
{
bi_buf |= value << bi_valid;
bi_valid += length;
}
} /* end send_bits */
/*
****************************************************************
* Reverse the first len bits of a code *
****************************************************************
*/
unsigned int
bi_reverse (register unsigned code, register int len)
{
register unsigned int left, right;
if (len < 8)
{
return (inv_byte[code] >> (8 - len));
}
elif (len == 8)
{
return (inv_byte[code]);
}
elif (len <= 16)
{
left = inv_byte[code >> 8];
right = inv_byte[code & 0xFF];
right <<= (len - 8);
left >>= (16 - len);
return (left | right);
}
else /* len > 16 */
{
fprintf (stderr, "bi_reverse: len = %d\n", len);
return (0);
}
#if (0) /*************************************/
register unsigned res = 0;
do
{
res |= code & 1;
code >>= 1, res <<= 1;
}
while (--len > 0);
return res >> 1;
#endif /*************************************/
} /* end bi_reverse */
/*
****************************************************************
* Write out any remaining bits in an incomplete byte *
****************************************************************
*/
void
bi_windup (void)
{
register ZIPFILE *zp1 = &zipfile;
register ulong u;
if (bi_valid > 8)
{
u = bi_buf; PUTZIP (u); PUTZIP (u >> 8);
}
elif (bi_valid > 0)
{
PUTZIP (bi_buf);
}
bi_buf = 0;
bi_valid = 0;
} /* end bi_windup */
/*
****************************************************************
* Copy a stored block to the zip file *
****************************************************************
*/
void
copy_block (register char *buf, register unsigned len, int header)
{
register ZIPFILE *zp1 = &zipfile;
register unsigned not_len;
bi_windup (); /* align on byte boundary */
if (header)
{
PUTZIP (len); PUTZIP (len >> 8);
not_len = ~len;
PUTZIP (not_len); PUTZIP (not_len >> 8);
}
while (len--)
{
PUTZIP (*buf++);
}
} /* end copy_block */
|
/**
* [POLYTECH APP3] Projet base de developpement en C
* Detcheberry Valentin
* Vuillemin Anthony
*/
#ifndef IMAGE_TOOLS_COMMAND_LINE_INTERFACE_H
#define IMAGE_TOOLS_COMMAND_LINE_INTERFACE_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "basic_tools.h"
#include "PGM_P2.h"
#include "BMP.h"
void cli(int argc, char** argv);
#endif
|
#include<stdio.h>
int main()
{
int p;
scanf("%d",&p);
while(p--)
{
unsigned long long int n,k,m,s=1,t=0;
scanf("%llu %llu %llu",&n,&k,&m);
if(n>m)
printf("0\n");
else
{
while(s<=m/n)
{
s=s*k;
if(s<=m/n)
t++;
}
printf("%llu\n",t);
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.