/** Write a section to the output. */
static void write_section(t3_config_t *config, FILE *file, int indent) {
while (config != NULL) {
if (config->type == T3_CONFIG_PLIST) {
write_plist(config, file, indent);
config = config->next;
continue;
}
write_indent(file, indent);
fputs(config->name, file);
switch (config->type) {
case T3_CONFIG_BOOL:
case T3_CONFIG_INT:
case T3_CONFIG_NUMBER:
case T3_CONFIG_STRING:
case T3_CONFIG_LIST:
fputs(" = ", file);
write_value(config, file, indent);
fputc('\n', file);
break;
case T3_CONFIG_SECTION:
fputc(' ', file);
write_value(config, file, indent);
fputc('\n', file);
break;
default:
/* This can only happen if the client screws up the list, which
the interface does not allow by itself. */
break;
}
config = config->next;
}
}
/*
* jsonwr_log10num_value
* Write a number that has been converted into log base 10
* because it may be too small to represent.
*/
void jsonwr_log10num_value(JSONWR_T* jsonwr, double value, int prec) {
double m, e;
m = 0;
e = 0;
if (value > -HUGE_VAL && value < HUGE_VAL) { // normal value
e = floor(value);
m = pow(10.0, value - e);
// check that rounding up won't cause a 9.9999 to go to a 10
if (m + (.5 * pow(10,-prec)) >= 10) {
m = 1;
e += 1;
}
str_clear(jsonwr->value_buf);
str_appendf(jsonwr->value_buf, "\"%.*fe%+04.0f\"", prec, m, e);
write_value(jsonwr);
} else if (value >= HUGE_VAL) { // infinity
str_clear(jsonwr->value_buf);
str_appendf(jsonwr->value_buf, "\"inf\"");
write_value(jsonwr);
} else { // negative infinity
str_clear(jsonwr->value_buf);
// note that m and e are both 0, but it is important that we pass them
// and not constants because if I pass a 0 then it is of int type which
// takes up less space on the stack then the format string is expecting
str_appendf(jsonwr->value_buf, "\"%.*fe%+04.0f\"", prec, m, e);
write_value(jsonwr);
}
}
int main( int argc, char** argv )
{
// Parse args and read values
const Args args = parse(argc,argv);
const int current = read_value("actual_brightness");
const int max = read_value("max_brightness");
int newval = current;
switch (args.mode)
{
case PRINT:
std::cout<<current<<" / "<<max<<std::endl;
break;
case PLUS:
case MINUS: // args.value is negtive in this case.
newval = clamp(current + args.value, 0, max);
write_value("brightness", newval);
break;
case ABSOLUTE:
newval = clamp(args.value, 0, max);
write_value("brightness", newval);
break;
case ERROR:
print_usage();
break;
}
// Return 0 if everything went fine, and 1 if not.
return args.mode == ERROR;
}
/*
* jsonwr_log10num_value
* Write a number that has been converted into log base 10
* because it may be too small to represent.
*/
void jsonwr_log10num_value(JSONWR_T* jsonwr, double value, int prec) {
double m, e;
m = 0;
e = 0;
if (value > -HUGE_VAL && value < HUGE_VAL) { // normal value
e = floor(value);
m = exp10(value - e);
// check that rounding up won't cause a 9.9999 to go to a 10
if (m + (.5 * pow(10,-prec)) >= 10) {
m = 1;
e += 1;
}
str_clear(jsonwr->value_buf);
str_appendf(jsonwr->value_buf, "\"%.*fe%+04.0f\"", prec, m, e);
write_value(jsonwr);
} else if (value >= HUGE_VAL) { // infinity
str_clear(jsonwr->value_buf);
str_appendf(jsonwr->value_buf, "\"inf\"");
write_value(jsonwr);
} else { // negative infinity
str_clear(jsonwr->value_buf);
str_appendf(jsonwr->value_buf, "\"%.*fe%+04.0f\"", prec, 0, 0);
write_value(jsonwr);
}
}
void msg_parser(char *msg_req_buffer, char *msg_resp_buffer, uint32_t *msg_len)
{
msg_req_t * req;
msg_val_t ret_msg_val;
/* Store req and resp buffers into global context
* to work for current message */
g_msg_parser_ctxt->msg_req_buffer = msg_req_buffer;
g_msg_parser_ctxt->msg_resp_buffer = msg_resp_buffer;
g_msg_parser_ctxt->msg_len = msg_len;
#if 0
{
uint16_t i;
printf("Bytes : ");
for (i=0; i<sizeof(msg_req_t); i++) {
printf("%x ,", (uint8_t)msg_req_buffer[i]);
}
printf("\n");
}
#endif
req = (msg_req_t *) msg_req_buffer;
if (req->req_type==KEEP_ALIVE_REQ) {
msg_parser_resp(req->handle, req->req_type, STATUS_OK);
} else {
ret_msg_val = -1;
switch (req->req_type) {
case BYTE_READ_REQ:
ret_msg_val = read_value(req->addr, 1);
break;
case BYTE_WRITE_REQ:
write_value(req->addr, req->value, 1);
break;
case HALF_WORD_READ_REQ:
ret_msg_val = read_value(req->addr, 2);
break;
case HALF_WORD_WRITE_REQ:
write_value(req->addr, req->value, 2);
break;
case WORD_READ_REQ:
ret_msg_val = read_value(req->addr, 4);
break;
case WORD_WRITE_REQ:
write_value(req->addr, req->value, 4);
break;
default:
assert(0, ASSERT_FATAL);
}
msg_parser_resp(req->handle, req->req_type, STATUS_OK,
req->addr, ret_msg_val);
}
#if 0
{
uint16_t i;
printf("Bytes : ");
for (i=0; i<sizeof(msg_resp_t); i++) {
printf("%x ,", (uint8_t)msg_resp_buffer[i]);
}
printf("\n");
}
#endif
}
void write_vector(scanner& sc, writer& wr, const value_vector_type& vec) {
bool wrap = vector_length(vec) > wr.wrap_length;
wr.append("[ ");
wr.indent();
if (wrap) {
wr.newline();
}
sc.expect('[');
unsigned int vals_read = 0;
while (!sc.peek_token().is_char(']')) {
if (vals_read < vec.size()) {
write_value(sc, wr, vec[vals_read]);
vals_read++;
} else {
read_value(sc);
}
bool terminate = sc.peek_token().is_char(']') && vals_read == vec.size();
if (!terminate) {
if (wrap) {
wr.newline();
} else {
wr.append(", ");
}
} else if (!wrap) {
wr.append(" ");
}
sc.expect(',', true);
}
for (unsigned int i = vals_read; i < vec.size(); i++) {
scanner dummy_scanner = make_scanner("0");
write_value(dummy_scanner, wr, vec[i]);
if (i < vec.size() - 1) {
if (wrap) {
wr.newline();
} else {
wr.append(", ");
}
} else if (!wrap) {
wr.append(" ");
}
}
wr.unindent();
if (wrap) {
wr.newline();
}
sc.expect(']');
wr.append("]");
}
Config *
config_create()
{
Config *config = malloc(sizeof(Config));
config->document_root = NULL;
config->config_dir = NULL;
write_value(&config->document_root, CONFIG_DEFAULT_DOCUMENT_ROOT, CONFIG_VALUE_MAX_LENGTH);
write_value(&config->config_dir, CONFIG_DEFAULT_CONFIG_DIR, CONFIG_VALUE_MAX_LENGTH);
config->port = CONFIG_DEFAULT_PORT;
return config;
}
void write_value(const reflectable& source_reflectable, symbol& target_symbol)
{
VAL& type = get_type(source_reflectable);
VAL& type_index = get_type_index(*type);
VAL& type_descriptor = get_type_descriptor(type_index);
write_value(*type_descriptor, static_cast<const void*>(&source_reflectable), target_symbol);
}
void binary_serializer::write_tuple(size_t size,
const primitive_variant* values) {
const primitive_variant* end = values + size;
for ( ; values != end; ++values) {
write_value(*values);
}
}
static int sendit(unsigned int timeout_ms)
{
char value[TIMEOUT_STR_LEN]; /* large enough for millions of years */
snprintf(value, sizeof(value), "%u", timeout_ms);
return write_value(THE_DEVICE, value);
}
void
TextEdit::set_text(const char *_text)
{
strncpy(value, _text, size);
value[size] = 0;
write_value();
}
void sysfs_write(struct sysfs_def *def, int gpio, const char *attr, const char *value)
{
static char path[PATH_MAX];
snprintf(path, PATH_MAX, "/sys/class/%s/%s%d/%s", def->class, def->obj_prefix, gpio, attr);
path[PATH_MAX-1] = '\0';
write_value(path, value);
}
/*
* jsonwr_bool_value
* Write a boolean value
*/
void jsonwr_bool_value(JSONWR_T* jsonwr, int value) {
str_clear(jsonwr->value_buf);
if (value) {
str_append(jsonwr->value_buf, "true", 4);
} else {
str_append(jsonwr->value_buf, "false", 5);
}
write_value(jsonwr);
}
void
config_set(Config *config, int attr, void *value)
{
switch (attr) {
case CONFIG_DOCUMENT_ROOT:
write_value(&config->document_root, (char *)value, CONFIG_VALUE_MAX_LENGTH);
break;
case CONFIG_CONFIG_DIR:
write_value(&config->config_dir, (char *)value, CONFIG_VALUE_MAX_LENGTH);
break;
case CONFIG_PORT:
config->port = *(int *)value;
break;
default:
// TODO: error
break;
}
}
static pic_value
pic_write_display(pic_state *pic)
{
pic_value v, port = pic_stdout(pic);
pic_get_args(pic, "o|p", &v, &port);
write_value(pic, v, port, DISPLAY_MODE, OP_WRITE);
return pic_undef_value(pic);
}
static pic_value
pic_write_write_shared(pic_state *pic)
{
pic_value v, port = pic_stdout(pic);
pic_get_args(pic, "o|p", &v, &port);
write_value(pic, v, port, WRITE_MODE, OP_WRITE_SHARED);
return pic_undef_value(pic);
}
virtual void write_usage(std::ostream &out) const {
if (key != 0) {
out << '-' << key;
out << "/--" << long_name;
}
out << "\t" << description;
out << " Value: ";
write_value(out);
out << std::endl;
}
int mount_and_add(const char *controller, const char *path, const char *prop, const char *value)
{
char aux[1024], paux[1024], subdir[1024];
if (mkdir(dirname, 0700) < 0 && errno != EEXIST) {
pr_perror("Can't make dir");
return -1;
}
sprintf(subdir, "%s/%s", dirname, controller);
if (mkdir(subdir, 0700) < 0) {
pr_perror("Can't make dir");
return -1;
}
if (mount("none", subdir, "cgroup", 0, controller)) {
pr_perror("Can't mount cgroups");
goto err_rd;
}
sprintf(paux, "%s/%s", subdir, path);
mkdir(paux, 0600);
sprintf(paux, "%s/%s/%s", subdir, path, prop);
if (write_value(paux, value) < 0)
goto err_rs;
sprintf(aux, "%d", getpid());
sprintf(paux, "%s/%s/tasks", subdir, path);
if (write_value(paux, aux) < 0)
goto err_rs;
sprintf(paux, "%s/%s/special_prop_check", subdir, path);
mkdir(paux, 0600);
return 0;
err_rs:
umount(dirname);
err_rd:
rmdir(dirname);
return -1;
}
void sysfs_unexport(struct sysfs_def *def, int gpio)
{
static char path[PATH_MAX];
snprintf(path, PATH_MAX, "/sys/class/%s/unexport", def->class);
path[PATH_MAX-1] = '\0';
static char buffer[15];
sprintf(buffer, "%d", gpio);
write_value(path, buffer);
}
void Argument_helper::Argument_target::write_usage(std::ostream &out) const {
if (key != 0) {
out << '-' << key;
out << "/--" << long_name;
}
out << ' ' << arg_description;
out << "\t" << description;
out << " Value: ";
write_value(out);
out << std::endl;
}
void
Vcd_instrumenter::write_update(std::ostream& os,
ir::Time const& t) {
os << '#' << t.value(m_unit) << '\n';
std::size_t ref_counter = 0;
for(auto const& insp : m_inspected) {
for(std::size_t i=0; i<insp->num_elements(); ++i)
ref_counter = write_value(os, insp, i, ref_counter);
}
}
static void write_array(io::stream& e, const void* object, const bsreq* req, int level) {
if(level > 0 && req->count > 1)
e << "(";
for(unsigned index = 0; index < req->count; index++) {
if(index > 0)
e << ", ";
write_value(e, req->ptr(object, index), req, level);
}
if(level > 0 && req->count > 1)
e << ")";
}
void
Vcd_instrumenter::write_dump_all(std::ostream& os) {
os << "$dumpvars\n";
std::size_t ref_counter = 0;
for(auto const& insp : m_inspected) {
for(std::size_t i=0; i<insp->num_elements(); ++i)
ref_counter = write_value(os, insp, i, ref_counter);
}
os << "$end\n";
}
int main(){
Buffer buffer; // generate and init new buffer
buffer.read_offset = 0;
buffer.write_offset = 0;
buffer.isEmpty = 1;
buffer.isFull = 0;
buffer.mutex = 0;
int value = -1;
write_value( 4, &buffer ); // write and read some numbers
write_value( 8, &buffer );
value = read_value( &buffer );
write_value( 15, &buffer );
value = read_value( &buffer );
value = read_value( &buffer );
write_value( 16, &buffer );
write_value( 23, &buffer );
write_value( 42, &buffer );
value = read_value( &buffer );
value = read_value( &buffer );
value = read_value( &buffer );
return value;
}
void DeckOutput::write( const T& value ) {
if (default_count > 0) {
write_sep( );
os << default_count << "*";
default_count = 0;
row_count++;
}
write_sep( );
write_value( value );
row_count++;
}
static void cut_env(t_all *all, char ***env_dup)
{
char *name;
int ret;
ret = 0;
name = get_name(all->ch_arg[2]);
ret = name_search(ft_strdup(name), all);
if (ret != -1)
{
write_value(env_dup, ret);
ft_strdel(&name);
}
}
/** Write a list to the output. */
static void write_list(t3_config_t *config, FILE *file, int indent) {
t3_bool first = t3_true;
while (config != NULL) {
if (first) {
first = t3_false;
} else {
fputs(", ", file);
}
write_value(config, file, indent);
config = config->next;
}
}
bool
acdb_write_value_at_address(unsigned long address, int value)
{
const acdb_param *param = get_acdb_param();
if (!param) {
return false;
}
if (!write_value(param, address, value)) {
return true;
}
return false;
}
int main(void) {
while (1) {
refresh_inputs();
if (isSchedulable_done()) {
done();
} else if (isSchedulable_write_value()) {
int ports = 0;
if (!FIFO_HAS_ROOM(decoder_parser_blkexp_OUT)(&fifo_o_decoder_parser_blkexp_OUT, 1)) {
ports |= 0x01;
}
if (ports != 0) {
continue;
}
write_value();
} else if (isSchedulable_write_zero()) {
int ports = 0;
if (!FIFO_HAS_ROOM(decoder_parser_blkexp_OUT)(&fifo_o_decoder_parser_blkexp_OUT, 1)) {
ports |= 0x01;
}
if (ports != 0) {
continue;
}
write_zero();
} else if ((decoder_parser_blkexp_RUN_tokens >= 1) && (decoder_parser_blkexp_VALUE_tokens >= 1) && (decoder_parser_blkexp_LAST_tokens >= 1) && isSchedulable_read_immediate()) {
int ports = 0;
if (!FIFO_HAS_ROOM(decoder_parser_blkexp_OUT)(&fifo_o_decoder_parser_blkexp_OUT, 1)) {
ports |= 0x01;
}
if (ports != 0) {
continue;
}
read_immediate();
} else if ((decoder_parser_blkexp_RUN_tokens >= 1) && (decoder_parser_blkexp_VALUE_tokens >= 1) && (decoder_parser_blkexp_LAST_tokens >= 1) && isSchedulable_read_save()) {
int ports = 0;
if (!FIFO_HAS_ROOM(decoder_parser_blkexp_OUT)(&fifo_o_decoder_parser_blkexp_OUT, 1)) {
ports |= 0x01;
}
if (ports != 0) {
continue;
}
read_save();
} else {
continue;
}
}
}
int main(int argc, char** argv)
{
int concurrent;
if (argc != 2) {
puts("Give 1 for concurrent OpenCL kernel execution and 0 otherwise.");
exit(0);
}
concurrent = atoi(argv[1]);
init_device(concurrent);
write_value();
execute_device();
read_value();
return 0;
}
