bool
fw3_parse_device(void *ptr, const char *val, bool is_list)
{
char *p;
struct fw3_device dev = { };
if (*val == '*')
{
dev.set = true;
dev.any = true;
put_value(ptr, &dev, sizeof(dev), is_list);
return true;
}
if (*val == '!')
{
dev.invert = true;
while (isspace(*++val));
}
if ((p = strchr(val, '@')) != NULL)
{
*p++ = 0;
snprintf(dev.network, sizeof(dev.network), "%s", p);
}
if (*val)
snprintf(dev.name, sizeof(dev.name), "%s", val);
else
return false;
dev.set = true;
put_value(ptr, &dev, sizeof(dev), is_list);
return true;
}
// ---------------------------------------------------------------------------
//
// -----------
void bToolJustification::track_draw(){
bStdToolPres::track_draw();
if(!get_use_track()){
return;
}
if(!get_use_drag()){
return;
}
if(!_styl){
return;
}
CGPoint cgp;
i2dvertex vx;
get_cur(&vx);
if(vx.h==LONG_MIN){
return;
}
Convert(&cgp,&vx);
double val;
if(_umode==kJustificationUserModeStd){
if(_jkd==kJustificationKindOnPath){
val=get_justification_on_path(cgp);
if(val!=_curjust){
_curjust=val;
put_value(_fjust,val);
}
}
else if(_jkd==kJustificationKindOnPoint){
val=get_justification_on_point(cgp);
if(val!=_curjust){
_curjust=val;
put_value(_fjust,val);
}
}
}
else if(_umode==kJustificationUserModeSpace){
if(_jkd==kJustificationKindOnPath){
val=get_inter_on_path(cgp);
if(val!=_curspc){
_curspc=val;
put_value(_fspc,val);
}
}
else if(_jkd==kJustificationKindOnPoint){
val=get_inter_on_point(cgp);
if(val!=_curjust){
_curspc=val;
put_value(_fspc,val);
}
}
}
}
/*****************************************************************************
* A S S I G N _ H E L P E R 1 ( node *var, value val )
*
* Similare to assign_helper but used by reload_vars_hds.
* Therefore if the variable is a parameter given as a value, we assume it is
* not required to be reset.
******************************************************************************
*/
value
assign_helper1(node *var, value val)
{
node *param;
if ((param = lookup_symbol(string_part(var->val), SYM_PARAMETER))
!= NODENIL)
if (param->interpret == parameter_interpret)
return (put_value(symboltable_part(param->val),
string_part(param->sub[0]->val), SYM_VARIABLE, val));
else
return trueval;
else
return (put_value(activesymtab(SYM_VARIABLE), string_part(var->val),
SYM_VARIABLE, val));
}
Sophon_Result
sophon_insfile_store (Sophon_VM *vm, Sophon_Module *mod,
Sophon_IOFunc func, Sophon_Ptr data)
{
Sophon_U16 i;
SOPHON_ASSERT(vm && mod && func);
put_u32(func, data, SOPHON_INSFILE_MAGIC);
put_u32(func, data, SOPHON_INSFILE_VERSION);
if (mod->name)
put_str(vm, func, data, mod->name);
else
put_u32(func, data, 0);
put_u16(func, data, mod->const_count);
for (i = 0; i < mod->const_count; i++) {
put_value(vm, func, data, mod->consts[i]);
}
put_u16(func, data, mod->func_count);
for (i = 0; i < mod->func_count; i++) {
put_func(vm, func, data, mod->funcs[i]);
}
return SOPHON_OK;
}
static int
rs_update_out(struct trace_proc * proc, const message * m_out)
{
/*
* FIXME: this is a value from the wrong message union, and that is
* actually a minix bug.
*/
put_struct_rs_start(proc, "addr", (vir_bytes)m_out->m_rs_req.addr);
/* TODO: interpret these fields */
put_value(proc, "state", "%d", m_out->m_rs_update.state);
put_value(proc, "maxtime", "%d", m_out->m_rs_update.prepare_maxtime);
return CT_DONE;
}
/*
* Internal helper function used by WPACKET_close() and WPACKET_finish() to
* close a sub-packet and write out its length if necessary.
*/
static int wpacket_intern_close(WPACKET *pkt)
{
WPACKET_SUB *sub = pkt->subs;
size_t packlen = pkt->written - sub->pwritten;
if (packlen == 0
&& (sub->flags & WPACKET_FLAGS_NON_ZERO_LENGTH) != 0)
return 0;
if (packlen == 0
&& sub->flags & WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH) {
/* Deallocate any bytes allocated for the length of the WPACKET */
if ((pkt->curr - sub->lenbytes) == sub->packet_len) {
pkt->written -= sub->lenbytes;
pkt->curr -= sub->lenbytes;
}
/* Don't write out the packet length */
sub->packet_len = 0;
sub->lenbytes = 0;
}
/* Write out the WPACKET length if needed */
if (sub->lenbytes > 0
&& !put_value((unsigned char *)&pkt->buf->data[sub->packet_len],
packlen, sub->lenbytes))
return 0;
pkt->subs = sub->parent;
OPENSSL_free(sub);
return 1;
}
static int
vm_mmap_out(struct trace_proc * proc, const message * m_out)
{
if (m_out->m_mmap.flags & MAP_THIRDPARTY)
put_endpoint(proc, "forwhom", m_out->m_mmap.forwhom);
put_ptr(proc, "addr", (vir_bytes)m_out->m_mmap.addr);
put_value(proc, "len", "%zu", m_out->m_mmap.len);
put_flags(proc, "prot", mmap_prot, COUNT(mmap_prot), "0x%x",
m_out->m_mmap.prot);
put_flags(proc, "flags", mmap_flags, COUNT(mmap_flags), "0x%x",
m_out->m_mmap.flags);
put_fd(proc, "fd", m_out->m_mmap.fd);
put_value(proc, "offset", "%"PRId64, m_out->m_mmap.offset);
return CT_DONE;
}
/*
* Print a pointer. NULL is treated as a special case.
*/
void
put_ptr(struct trace_proc * proc, const char * name, vir_bytes addr)
{
if (addr == 0 && !valuesonly)
put_field(proc, name, "NULL");
else
put_value(proc, name, "&0x%lx", addr);
}
/******************************************************************************
*
* A S S I G N _ H E L P E R (node *var, value val)
*
* Assign the value 'val' to the variable 'var'.
* 'Var' is a name_interpret() node whose string_part member contains the
* identity of the variable.
*
* If the variable is a parameter then, on calling the current procedure we
* could have passed
* EITHER
* an expression, which is evaluated and the formal's value member points to
* that value
* OR
* a variable. In this latter case the formal's node value will point to a
* node whose type is TYPE_SYMTAB, whose interpret member is
* parameter_interpret(), whose symboltable_part() member points to the symbol
* table of the corresponding actual variable and whose sub[0] member points
* to a node that is the corresponding actual variable (ie a name_interpret()
* whose string_part() member points to the identifier).
*
* If the variable is not a parameter then we can use
* put_value(activesymtab(SYM_VARIABLE), var's name, SYM_VARIABLE,val)....) to
* achieve the storage otherwise we can use put_value(symboltable from formal
* entry, actual parameter's name,SYM_VARIABLE,val).
******************************************************************************
*/
value
assign_helper(node *var, value val)
{
node *param;
if ((param = lookup_symbol(string_part(var->val), SYM_PARAMETER))
!= NODENIL) {
if (param->interpret == parameter_interpret)
return (put_value(symboltable_part(param->val),
string_part(param->sub[0]->val), SYM_VARIABLE, val));
else if( param->interpret == undefined_interpret)
put_value(symbols, string_part(var->val), SYM_PARAMETER, val);
else
return exception(
"ASSNOTVAR Assignment to parameter not passed as a variable");
} else
return (put_value(activesymtab(SYM_VARIABLE), string_part(var->val),
SYM_VARIABLE, val));
}
/*
* Print a tail field at the end of an array. The given 'count' value is the
* total number of elements in the array, or 0 to indicate that an error
* occurred. The given 'printed' value is the number of fields printed so far.
* If some fields have been printed already, the number of fields not printed
* will be shown as "..(+N)". If no fields have been printed already, the
* (total) number of fields not printed will be shown as "..(N)". An error
* will print "..(?)".
*
* The rules for printing an array are as follows. In principle, arrays should
* be enclosed in "[]". However, if a copy error occurs immediately, a pointer
* to the array should be printed instead. An empty array should be printed as
* "[]" (not "[..(0)]"). If a copy error occurs in the middle of the array,
* put_tail should be used with count == 0. Only if not all fields in the
* array are printed, put_tail should be used with count > 0. The value of
* 'printed' is typically the result of an arbitrary limit set based on the
* verbosity level.
*/
void
put_tail(struct trace_proc * proc, unsigned int count, unsigned int printed)
{
if (count == 0)
put_field(proc, NULL, "..(?)");
else
put_value(proc, NULL, "..(%s%u)",
(printed > 0) ? "+" : "", count - printed);
}
static void
put_sound_state(struct trace_proc * proc, const char * name, int state)
{
if (!valuesonly && state == ON)
put_field(proc, name, "ON");
else if (!valuesonly && state == OFF)
put_field(proc, name, "OFF");
else
put_value(proc, name, "%d", state);
}
int WPACKET_put_bytes__(WPACKET *pkt, unsigned int val, size_t size)
{
unsigned char *data;
/* Internal API, so should not fail */
if (!ossl_assert(size <= sizeof(unsigned int))
|| !WPACKET_allocate_bytes(pkt, size, &data)
|| !put_value(data, val, size))
return 0;
return 1;
}
int mdhim_mysql_batch_put(void *dbh, void **keys, int32_t *key_lens,
void **data, int32_t *data_lens, int num_records) {
struct MDI *x = (struct MDI *)(dbh);
MYSQL *db = (MYSQL *) x->msqdb;
if (db == NULL)
{
fprintf(stderr, "%s\n", mysql_error(db));
return MDHIM_DB_ERROR;
}
int i;
struct timeval start, end;
gettimeofday(&start, NULL);
char *table_name = x->table;
char *query=NULL;
//Insert X amount of Keys and Values
printf("Number records: %d\n", num_records);
for (i = 0; i < num_records; i++) {
query = put_value(db, keys[i], key_lens[i], data[i], data_lens[i], table_name, x->msqkt);
printf("\nThis is the query: \n%s\n", query);
if (mysql_real_query(db, query, sizeof(char)*strlen(query))) {
int check_er = mysql_errno(db);
//printf("\nThis is the error number: %d\n", check_er);
if (check_er == 1062){
memset(query, 0, sizeof(char)*strlen(query));
query = update_value(db, keys[i], key_lens[i], data[i], data_lens[i], table_name, x->msqkt);
//printf("\nThis is the query: \n%s\n", query);
if (mysql_real_query(db, query, sizeof(char)*strlen(query))) {
//printf("This is the query: %s\n", query);
mlog(MDHIM_SERVER_CRIT, "Error updating key/value in mysql\n");
fprintf(stderr, "%s\n", mysql_error(db));
return MDHIM_DB_ERROR;
}
//else printf("Sucessfully updated key/value in mdhim\n");
}
else {
mlog(MDHIM_SERVER_CRIT, "Error putting key/value in mysql\n");
fprintf(stderr, "%s\n", mysql_error(db));
return MDHIM_DB_ERROR;
}
}
memset(query, 0, sizeof(query));
}
//Report timing
gettimeofday(&end, NULL);
mlog(MDHIM_SERVER_DBG, "Took: %d seconds to put %d records",
(int) (end.tv_sec - start.tv_sec), num_records);
return MDHIM_SUCCESS;
}
int main()
{
unsigned char* ptr = Program;
/* так можно размещать перемнные до запуска ВМ */
add_var("pi");
set_var("pi", 3.14159265);
/* так создаются пермеменные в программе ВМ */
put_commd(&ptr, CNVAR); put_strng(&ptr, "x1");
put_commd(&ptr, CPUSH); put_value(&ptr, 2.0);
put_commd(&ptr, CSVAR); put_strng(&ptr, "x1");
/* вычисление выражения (2.3+4.7)*2.1 */
put_commd(&ptr, CPUSH); put_value(&ptr, 2.3);
put_commd(&ptr, CPUSH); put_value(&ptr, 4.7);
put_commd(&ptr, CADD);
put_commd(&ptr, CPUSH); put_value(&ptr, 2.1);
put_commd(&ptr, CMULT);
/* делим результат на Pi */
put_commd(&ptr, CGVAR); put_strng(&ptr, "pi");
put_commd(&ptr, CDIV);
/* умножаем на x1 */
put_commd(&ptr, CGVAR); put_strng(&ptr, "x1");
put_commd(&ptr, CMULT);
/* выводим результат, останавливаем машину */
put_commd(&ptr, COUT);
put_commd(&ptr, CHALT);
vmin = stdin;
vmout = stdout;
run();
return 1;
}
/**
* mdhim_mysql_put
* Stores a single key in the data store
*
* @param dbh in pointer to the mysql struct which points to the handle
* @param key in void * to the key to store
* @param key_len in length of the key
* @param data in void * to the value of the key
* @param data_len in length of the value data
* @param mstore_opts in additional options for the data store layer
*
* @return MDHIM_SUCCESS on success or MDHIM_DB_ERROR on failure
*/
int mdhim_mysql_put(void *dbh, void *key, int key_len, void *data, int32_t data_len) {
struct timeval start, end;
//printf("In put function\n");
struct MDI *x = (struct MDI *)(dbh);
MYSQL *db = x->msqdb;
if (db == NULL)
{
fprintf(stderr, "%s\n", mysql_error(db));
return MDHIM_DB_ERROR;
}
char *table_name;
table_name = x->table;
gettimeofday(&start, NULL);
char *query;
//Insert key and value into table
query = put_value(db, key, key_len, data, data_len, table_name, x->msqkt);
//printf("\nThis is the query: \n%s\n", query);
if (mysql_real_query(db, query, sizeof(char)*strlen(query))) {
int check_er = mysql_errno(db);
//printf("\nThis is the error number: %d\n", check_er);
if (check_er == 1062){
memset(query, 0, sizeof(char)*strlen(query));
query = update_value(db, key, key_len, data, data_len, table_name, x->msqkt);
//printf("\nThis is the query: \n%s\n", query);
if (mysql_real_query(db, query, sizeof(char)*strlen(query))) {
//printf("This is the query: %s\n", query);
mlog(MDHIM_SERVER_CRIT, "Error updating key/value in mysql\n");
fprintf(stderr, "%s\n", mysql_error(db));
return MDHIM_DB_ERROR;
}
//else printf("Sucessfully updated key/value in mdhim\n");
}
else {
mlog(MDHIM_SERVER_CRIT, "Error putting key/value in mysql\nHere is the command:%s\n",query);
fprintf(stderr, "%s\n", mysql_error(db));
return MDHIM_DB_ERROR;
}
}
//Report timing
gettimeofday(&end, NULL);
mlog(MDHIM_SERVER_DBG, "Took: %d seconds to put the record",
(int) (end.tv_sec - start.tv_sec));
return MDHIM_SUCCESS;
}
static long process(compressRecord *prec)
{
long status=0;
long nelements = 0;
int alg = prec->alg;
prec->pact = TRUE;
if(!dbIsLinkConnected(&prec->inp)
|| dbGetNelements(&prec->inp,&nelements)
|| nelements<=0) {
recGblSetSevr(prec,LINK_ALARM,INVALID_ALARM);
} else {
if(!prec->wptr || nelements!=prec->inpn) {
if(prec->wptr) {
free(prec->wptr);
reset(prec);
}
prec->wptr = (double *)dbCalloc(nelements,sizeof(double));
prec->inpn = nelements;
}
status = dbGetLink(&prec->inp,DBF_DOUBLE,prec->wptr,0,&nelements);
if(status || nelements<=0) {
recGblSetSevr(prec,LINK_ALARM,INVALID_ALARM);
status = 0;
} else {
if(alg==compressALG_Average) {
status = array_average(prec,prec->wptr,nelements);
} else if(alg==compressALG_Circular_Buffer) {
(void)put_value(prec,prec->wptr,nelements);
status = 0;
} else if(nelements>1) {
status = compress_array(prec,prec->wptr,nelements);
}else if(nelements==1){
status = compress_scalar(prec,prec->wptr);
}else status=1;
}
}
/* check event list */
if(status!=1) {
prec->udf=FALSE;
recGblGetTimeStamp(prec);
monitor(prec);
/* process the forward scan link record */
recGblFwdLink(prec);
}
prec->pact=FALSE;
return(0);
}
static int array_average(compressRecord *prec,
double *psource,epicsInt32 no_elements)
{
epicsInt32 i;
epicsInt32 nnow;
epicsInt32 nsam=prec->nsam;
double *psum;
double multiplier;
epicsInt32 inx=prec->inx;
epicsInt32 nuse,n;
nuse = nsam;
if(nuse>no_elements) nuse = no_elements;
nnow=nuse;
if(nnow>no_elements) nnow=no_elements;
psum = (double *)prec->sptr;
/* add in the new waveform */
if (inx == 0){
for (i = 0; i < nnow; i++)
*psum++ = *psource++;
for(i=nnow; i<nuse; i++) *psum++ = 0;
}else{
for (i = 0; i < nnow; i++)
*psum++ += *psource++;
}
/* do we need to calculate the result */
inx++;
if(prec->n<=0)prec->n=1;
n = prec->n;
if (inx<n) {
prec->inx = inx;
return(1);
}
if(n>1) {
psum = (double *)prec->sptr;
multiplier = 1.0/((double)n);
for (i = 0; i < nuse; i++, psum++)
*psum = *psum * multiplier;
}
put_value(prec,prec->sptr,nuse);
prec->inx = 0;
return(0);
}
static int test_gencode()
{
yla_cop_type buf[100];
yla_cop_type *ptr = buf;
put_commd(&ptr, 0x12);
put_value(&ptr, 0x3456);
put_commd(&ptr, 0x78);
put_commd(&ptr, 0x9a);
YLATEST_ASSERT_TRUE(buf[0] == 0x12, "put_commd");
YLATEST_ASSERT_TRUE(buf[1] == 0x34, "put_value");
YLATEST_ASSERT_TRUE(buf[2] == 0x56, "put_value");
YLATEST_ASSERT_TRUE(buf[3] == 0x78, "put_value");
YLATEST_ASSERT_TRUE(buf[4] == 0x9a, "put_value");
return 0;
}
static int test_push()
{
yla_cop_type prg[HEADER_SIZE + 4];
yla_cop_type *ptr = prg;
put_header(&ptr, 1, 0, 4);
put_commd(&ptr, CPUSH);
put_value(&ptr, 0x1234);
put_commd(&ptr, CHALT);
yla_vm vm;
YLATEST_ASSERT_TRUE(yla_vm_init(&vm, prg, HEADER_SIZE + 4), "normal");
YLATEST_ASSERT_TRUE(yla_vm_run(&vm), "normal")
YLATEST_ASSERT_TRUE(yla_vm_done(&vm), "normal");
return 0;
}
/*
* Print a flags field, using known flag names. The name of the whole field is
* given as 'name' and may be NULL. The caller must supply an array of known
* flags as 'fp' (with 'num' entries). Each entry in the array has a mask, a
* value, and a name. If the given flags 'value', bitwise-ANDed with the mask
* of an entry, yields the value of that entry, then the name is printed. This
* means that certain zero bits may also be printed as actual flags, and that
* by supplying an all-bits-set mask can print a flag name for a zero value,
* for example F_OK for access(). See the FLAG macros and their usage for
* examples. All matching flag names are printed with a "|" separator, and if
* after evaluating all 'num' entries in 'fp' there are still bits in 'value'
* for which nothing has been printed, the remaining bits will be printed with
* the 'fmt' format string for an integer (generally "%d" should be used).
*/
void
put_flags(struct trace_proc * proc, const char * name, const struct flags * fp,
unsigned int num, const char * fmt, unsigned int value)
{
unsigned int left;
int first;
if (valuesonly) {
put_value(proc, name, fmt, value);
return;
}
put_field(proc, name, "");
for (first = TRUE, left = value; num > 0; fp++, num--) {
if ((value & fp->mask) == fp->value) {
if (first)
first = FALSE;
else
put_text(proc, "|");
put_text(proc, fp->name);
left -= fp->value;
}
}
if (left != 0) {
if (first)
first = FALSE;
else
put_text(proc, "|");
put_fmt(proc, fmt, left);
}
/*
* If nothing has been printed so far, simply print a zero. Ignoring
* the given format in this case is intentional: a simple 0 looks
* better than 0x0 or 00 etc.
*/
if (first)
put_text(proc, "0");
}
int main()
{
struct indicator *indicators;
struct strategy *strategies;
struct coll_ctrl_blk *coll_ctrl_blks;
indicators = load_indicators("indicators.xml");
print_indicators(indicators);
//destroy_indicators(indicators);
strategies = load_strategies("strategies.xml");
print_strategies(strategies);
//destroy_strategies(strategies);
//printf("name offset in Indicator is: %u\n", offsetof(struct indicator, name));
//printf("size of int: %u\n", sizeof(int));
struct data data;
init_data(&data);
put_value(&data, "hello", "wold");
struct pair *pair_ptr = get_pair(&data, "hello");
printf("%s, %s\n", pair_ptr->name, pair_ptr->value);
coll_ctrl_blks = generate_coll_ctrl_blks(indicators, strategies);
print_coll_ctrl_blks(coll_ctrl_blks);
struct coll_ctrl_blk *coll_ctrl_blk_ptr = find_coll_ctrl_blk(coll_ctrl_blks, 1);
printf("Indicator NAME: %s\n", coll_ctrl_blk_ptr->indicator_ptr->name);
generate_coll_commands(coll_ctrl_blk_ptr);
destroy_indicators(indicators);
destroy_strategies(strategies);
ssh_init();
struct ssh_client client;
struct line *lines;
init_client(&client);
login(&client, "127.0.0.1", 22, "tshi", "123456");
lines = exec_command(&client, "date");
print_lines(lines);
destroy_lines(lines);
lines = exec_command(&client, "top -b -n 1");
print_lines(lines);
destroy_lines(lines);
close_client(&client);
ssh_exit();
return (0);
}
static int test_get_stack_full()
{
yla_cop_type prg[HEADER_SIZE + 4];
yla_cop_type *ptr = prg;
put_header(&ptr, 0, 0, 4);
put_commd(&ptr, CPUSH);
put_value(&ptr, 0x1234);
put_commd(&ptr, CHALT);
yla_vm vm;
YLATEST_ASSERT_TRUE(yla_vm_init(&vm, prg, HEADER_SIZE + 4), "normal");
YLATEST_ASSERT_FALSE(yla_vm_run(&vm), "normal")
YLATEST_ASSERT_TRUE(yla_vm_last_error(&vm) == YLA_VM_ERROR_STACK_FULL, "incorrect error code");
YLATEST_ASSERT_TRUE(yla_vm_done(&vm), "normal");
return 0;
}
static void
put_fbd_action(struct trace_proc * proc, const char * name, int action)
{
const char *text = NULL;
if (!valuesonly) {
switch (action) {
TEXT(FBD_ACTION_CORRUPT);
TEXT(FBD_ACTION_ERROR);
TEXT(FBD_ACTION_MISDIR);
TEXT(FBD_ACTION_LOSTTORN);
}
}
if (text != NULL)
put_field(proc, name, text);
else
put_value(proc, name, "%d", action);
}
static void
put_tty_disc(struct trace_proc * proc, const char * name, int disc)
{
const char *text = NULL;
if (!valuesonly) {
switch (disc) {
TEXT(TTYDISC);
TEXT(TABLDISC);
TEXT(SLIPDISC);
TEXT(PPPDISC);
TEXT(STRIPDISC);
TEXT(HDLCDISC);
}
}
if (text != NULL)
put_field(proc, name, text);
else
put_value(proc, name, "%d", disc);
}
static void
put_i2c_op(struct trace_proc * proc, const char *name, i2c_op_t op)
{
const char *text = NULL;
if (!valuesonly) {
switch (op) {
TEXT(I2C_OP_READ);
TEXT(I2C_OP_READ_WITH_STOP);
TEXT(I2C_OP_WRITE);
TEXT(I2C_OP_WRITE_WITH_STOP);
TEXT(I2C_OP_READ_BLOCK);
TEXT(I2C_OP_WRITE_BLOCK);
}
}
if (text != NULL)
put_field(proc, name, text);
else
put_value(proc, name, "%d", op);
}
void uart_hardware_init(void)
{
//HAS_CRITICAL_SECTION;
//ENTER_CRITICAL_SECTION();
//LEAVE_CRITICAL_SECTION();
if(uart_initialized == false) {
set_hbit(GPCTL,GPCTL_UART);
put_hvalue(GPPMB,0); // disable SIO bits 6 and 7
put_hvalue(GPPOB,0);
put_hvalue(GPPMA,0x0002); // RX is input (A0), TX is output (A1)
put_hvalue(GPPOA,0);
put_value(UARTIER,0); // no interrupts
put_value(UARTLCR,0x80); // enable access to divisor latch
put_value(UARTDLM,0);
put_value(UARTDLL,0x3E); // 57600 baud
put_value(UARTLCR,0x03);
put_value(UARTFCR,0xC7); // 14 byte trigger, cleared and buffered (auto set to normal FCR mode)
put_value(UARTMCR,0);
put_value(UARTIER,0x01); // RX
IRQ_HANDLER_TABLE[INT_UART]=uart_interrupt_handler;
set_wbit(ILC1,ILC1_ILR9 & ILC1_INT_LV3);
set_hbit(GPPMC, UART_EN); // set PIOC6(UART_EN) to output
set_hbit(GPPMC, UART_FORCEOFF); // set PIOC7(FORCEOFF) to output
set_hbit(GPCTL,GPCTL_UART);
put_hvalue(GPPMA,0x0002); // RX is input (A0), TX is output (A1)
put_hvalue(GPPOA,0);
clr_hbit(GPPOC,UART_EN);
set_hbit(GPPOC,UART_FORCEOFF); // this also drives FORCEON -- they are tied together
uart_initialized = true;
}
}
/*
* Internal helper function used by WPACKET_close(), WPACKET_finish() and
* WPACKET_fill_lengths() to close a sub-packet and write out its length if
* necessary. If |doclose| is 0 then it goes through the motions of closing
* (i.e. it fills in all the lengths), but doesn't actually close anything.
*/
static int wpacket_intern_close(WPACKET *pkt, WPACKET_SUB *sub, int doclose)
{
size_t packlen = pkt->written - sub->pwritten;
if (packlen == 0
&& (sub->flags & WPACKET_FLAGS_NON_ZERO_LENGTH) != 0)
return 0;
if (packlen == 0
&& sub->flags & WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH) {
/* We can't handle this case. Return an error */
if (!doclose)
return 0;
/* Deallocate any bytes allocated for the length of the WPACKET */
if ((pkt->curr - sub->lenbytes) == sub->packet_len) {
pkt->written -= sub->lenbytes;
pkt->curr -= sub->lenbytes;
}
/* Don't write out the packet length */
sub->packet_len = 0;
sub->lenbytes = 0;
}
/* Write out the WPACKET length if needed */
if (sub->lenbytes > 0
&& !put_value(&GETBUF(pkt)[sub->packet_len], packlen,
sub->lenbytes))
return 0;
if (doclose) {
pkt->subs = sub->parent;
OPENSSL_free(sub);
}
return 1;
}
static int compress_scalar(struct compressRecord *prec,double *psource)
{
double value = *psource;
double *pdest=&prec->cvb;
epicsInt32 inx = prec->inx;
/* compress according to specified algorithm */
switch (prec->alg){
case (compressALG_N_to_1_Low_Value):
if ((value < *pdest) || (inx == 0))
*pdest = value;
break;
case (compressALG_N_to_1_High_Value):
if ((value > *pdest) || (inx == 0))
*pdest = value;
break;
/* for scalars, Median not implemented => use average */
case (compressALG_N_to_1_Average):
case (compressALG_N_to_1_Median):
if (inx == 0)
*pdest = value;
else {
*pdest += value;
if(inx+1>=(prec->n)) *pdest = *pdest/(inx+1);
}
break;
}
inx++;
if(inx>=prec->n) {
put_value(prec,pdest,1);
prec->inx = 0;
return(0);
} else {
prec->inx = inx;
return(1);
}
}
iter_type put(duration_units<CharT> const& units_facet, iter_type s, std::ios_base& ios, char_type fill,
duration<Rep, Period> const& d, const CharT* pattern, const CharT* pat_end) const
{
const std::ctype<char_type>& ct = std::use_facet<std::ctype<char_type> >(ios.getloc());
for (; pattern != pat_end; ++pattern)
{
if (ct.narrow(*pattern, 0) == '%')
{
if (++pattern == pat_end)
{
*s++ = pattern[-1];
break;
}
char fmt = ct.narrow(*pattern, 0);
switch (fmt)
{
case 'v':
{
s = put_value(s, ios, fill, d);
break;
}
case 'u':
{
s = put_unit(units_facet, s, ios, fill, d);
break;
}
default:
BOOST_ASSERT(false && "Boost::Chrono internal error.");
break;
}
}
else
*s++ = *pattern;
}
return s;
}
static void
put_sound_device(struct trace_proc * proc, const char * name, int device)
{
const char *text = NULL;
if (!valuesonly) {
switch (device) {
TEXT(Master);
TEXT(Dac);
TEXT(Fm);
TEXT(Cd);
TEXT(Line);
TEXT(Mic);
TEXT(Speaker);
TEXT(Treble);
TEXT(Bass);
}
}
if (text != NULL)
put_field(proc, name, text);
else
put_value(proc, name, "%d", device);
}