/*
* Recursively prints a tree of ini_pairs
*/
static void write_pair(ini_pair *p, FILE *f) {
if(!p) return;
string_to_file(f, p->param);
fputs(" = ", f);
string_to_file(f, p->value);
fputc('\n', f);
write_pair(p->left, f);
write_pair(p->right, f);
}
void write(port *out, pointer object)
{
if (object == NULL) {
printf("()");
return;
}
switch (type(object)) {
case T_STRING:
write_string(out, object);
break;
case T_NUMBER:
write_number(out, object);
break;
case T_SYMBOL:
write_symbol(out, object);
break;
case T_PAIR:
write_pair(out, object);
break;
case T_BUILT_IN_REGULAR_PROC:
case T_BUILT_IN_SPECIAL_PROC:
case T_EXTEND_PROC:
write_proc(out, object);
break;
case T_MACRO:
write_macro(out, object);
break;
default:
wirte_unknown(out, object);
break;
}
}
/* add a lastError message on the end of the buffer.
* returns 0 on failure */
static int add_last_error(buffer_t buffer, int request_id, PyObject* args) {
int message_start;
int document_start;
int message_length;
int document_length;
PyObject* key;
PyObject* value;
Py_ssize_t pos = 0;
PyObject* one;
message_start = buffer_save_space(buffer, 4);
if (message_start == -1) {
PyErr_NoMemory();
return 0;
}
if (!buffer_write_bytes(buffer, (const char*)&request_id, 4) ||
!buffer_write_bytes(buffer,
"\x00\x00\x00\x00" /* responseTo */
"\xd4\x07\x00\x00" /* opcode */
"\x00\x00\x00\x00" /* options */
"admin.$cmd\x00" /* collection name */
"\x00\x00\x00\x00" /* skip */
"\xFF\xFF\xFF\xFF", /* limit (-1) */
31)) {
return 0;
}
/* save space for length */
document_start = buffer_save_space(buffer, 4);
if (document_start == -1) {
PyErr_NoMemory();
return 0;
}
/* getlasterror: 1 */
one = PyLong_FromLong(1);
if (!write_pair(buffer, "getlasterror", 12, one, 0, 4, 1)) {
Py_DECREF(one);
return 0;
}
Py_DECREF(one);
/* getlasterror options */
while (PyDict_Next(args, &pos, &key, &value)) {
if (!decode_and_write_pair(buffer, key, value, 0, 4, 0)) {
return 0;
}
}
/* EOD */
if (!buffer_write_bytes(buffer, "\x00", 1)) {
return 0;
}
message_length = buffer_get_position(buffer) - message_start;
document_length = buffer_get_position(buffer) - document_start;
memcpy(buffer_get_buffer(buffer) + message_start, &message_length, 4);
memcpy(buffer_get_buffer(buffer) + document_start, &document_length, 4);
return 1;
}
static void write_pair(pSlip gd, pSlipObject pair)
{
pSlipObject car_obj;
pSlipObject cdr_obj;
car_obj = car(pair);
cdr_obj = cdr(pair);
slip_write(gd, car_obj);
if (cdr_obj->type == eType_PAIR)
{
printf(" ");
write_pair(gd, cdr_obj);
}
else if (cdr_obj->type == eType_EMPTY_LIST)
{
return;
}
else
{
printf(" . ");
slip_write(gd, cdr_obj);
}
}
static int update_display_mode(struct dc_disp_reg *disp,
struct tegra_lcd_priv *priv)
{
unsigned long val;
unsigned long rate;
unsigned long div;
writel(0x0, &disp->disp_timing_opt);
write_pair(priv, FDT_LCD_TIMING_REF_TO_SYNC, &disp->ref_to_sync);
write_pair(priv, FDT_LCD_TIMING_SYNC_WIDTH, &disp->sync_width);
write_pair(priv, FDT_LCD_TIMING_BACK_PORCH, &disp->back_porch);
write_pair(priv, FDT_LCD_TIMING_FRONT_PORCH, &disp->front_porch);
writel(priv->width | (priv->height << 16), &disp->disp_active);
val = DE_SELECT_ACTIVE << DE_SELECT_SHIFT;
val |= DE_CONTROL_NORMAL << DE_CONTROL_SHIFT;
writel(val, &disp->data_enable_opt);
val = DATA_FORMAT_DF1P1C << DATA_FORMAT_SHIFT;
val |= DATA_ALIGNMENT_MSB << DATA_ALIGNMENT_SHIFT;
val |= DATA_ORDER_RED_BLUE << DATA_ORDER_SHIFT;
writel(val, &disp->disp_interface_ctrl);
/*
* The pixel clock divider is in 7.1 format (where the bottom bit
* represents 0.5). Here we calculate the divider needed to get from
* the display clock (typically 600MHz) to the pixel clock. We round
* up or down as requried.
*/
rate = clock_get_periph_rate(PERIPH_ID_DISP1, CLOCK_ID_CGENERAL);
div = ((rate * 2 + priv->pixel_clock / 2) / priv->pixel_clock) - 2;
debug("Display clock %lu, divider %lu\n", rate, div);
writel(0x00010001, &disp->shift_clk_opt);
val = PIXEL_CLK_DIVIDER_PCD1 << PIXEL_CLK_DIVIDER_SHIFT;
val |= div << SHIFT_CLK_DIVIDER_SHIFT;
writel(val, &disp->disp_clk_ctrl);
return 0;
}
/*
* Recursively prints a tree of INI sections
*/
static void write_section(ini_section *s, FILE *f) {
if(!s) return;
fputs("\n[", f);
string_to_file(f, s->name);
fputs("]\n", f);
write_pair(s->fields, f);
/* The akward sequence is to ensure that values are not written sorted */
write_section(s->left, f);
write_section(s->right, f);
}
static str* write_dialog_profiles( struct dlg_profile_link *links)
{
static str o = {NULL,0};
static int o_l = 0;
struct dlg_profile_link *link;
unsigned int l,i;
char *p;
/* compute the required len */
for ( link=links,l=0 ; link ; link=link->next) {
l += link->profile->name.len + 1 + link->value.len + 1;
for( i=0 ; i<link->profile->name.len ; i++ )
if (link->profile->name.s[i]=='|' || link->profile->name.s[i]=='#'
|| link->profile->name.s[i]=='\\') l++;
for( i=0 ; i<link->value.len ; i++ )
if (link->value.s[i]=='|' || link->value.s[i]=='#'
|| link->value.s[i]=='\\') l++;
}
/* allocate the string to be stored */
if ( o.s==NULL || o_l<l) {
if (o.s) pkg_free(o.s);
o.s = (char*)pkg_malloc(l);
if (o.s==NULL) {
LM_ERR("not enough pkg mem (req=%d)\n",l);
return NULL;
}
o_l = l;
}
/* write the stuff into it */
o.len = l;
p = o.s;
for ( link=links; link ; link=link->next) {
p += write_pair( p, &link->profile->name, &link->value);
}
if (o.len!=p-o.s) {
LM_CRIT("BUG - buffer overflow allocated %d, written %d\n",
o.len,(int)(p-o.s));
return NULL;
}
LM_DBG("profile string is <%.*s>(%d)\n", l,o.s,l);
return &o;
}
/*
* Saves all the sections and parameters in an ini_file to a file.
* If fname is NULL, it is written to stdout.
*/
int ini_write(struct ini_file *ini, const char *fname) {
FILE *f;
if(fname) {
f = fopen(fname, "w");
if(!f)
return ER_FOPEN;
} else
f = stdout;
write_pair(ini->globals, f);
write_section(ini->sections, f);
if(fname)
fclose(f);
return SUCCESS;
}
void write_pair(obj_t pair) {
obj_t car_obj;
obj_t cdr_obj;
car_obj = car(pair);
cdr_obj = cdr(pair);
write(car_obj);
if (is_pair(cdr_obj)) {
printf(" ");
write_pair(cdr_obj);
}
else if (cdr_obj == imm_empty_list) {
return;
}
else {
printf(" . ");
write(cdr_obj);
}
}
void write_pair(FILE *out, object *pair) {
object *car_obj;
object *cdr_obj;
car_obj = car(pair);
cdr_obj = cdr(pair);
write(out, car_obj);
if (cdr_obj->type == EMPTY_LIST)
return;
if (cdr_obj->type == PAIR) {
fprintf(out, " ");
write_pair(out, cdr_obj);
} else {
fprintf(out, " . ");
write(out, cdr_obj);
}
}
static void write_pair(object pair, FILE *out)
{
object car_obj, cdr_obj;
car_obj = car(pair);
cdr_obj = cdr(pair);
lisp_print(car_obj, out);
if (is_pair(cdr_obj)) {
fprintf(out, " ");
write_pair(cdr_obj, out);
}
else if (is_null(cdr_obj)) {
return;
}
else {
fprintf(out, " . ");
lisp_print(cdr_obj, out);
}
}
void query_update::write(const char *id, long x)
{
write_pair(id, type_long, x);
}
void query_update::write(const char *id, int x)
{
write_pair(id, type_int, x);
}
static void
write_core(pic_state *pic, pic_value obj, pic_value port, struct writer_control *p)
{
pic_value labels = p->labels;
int i;
/* shared objects */
if (is_shared_object(pic, obj, p)) {
if (pic_weak_has(pic, labels, obj)) {
pic_fprintf(pic, port, "#%d#", pic_int(pic, pic_weak_ref(pic, labels, obj)));
return;
}
i = p->cnt++;
pic_fprintf(pic, port, "#%d=", i);
pic_weak_set(pic, labels, obj, pic_int_value(pic, i));
}
switch (pic_type(pic, obj)) {
case PIC_TYPE_UNDEF:
pic_fprintf(pic, port, "#undefined");
break;
case PIC_TYPE_NIL:
pic_fprintf(pic, port, "()");
break;
case PIC_TYPE_TRUE:
pic_fprintf(pic, port, "#t");
break;
case PIC_TYPE_FALSE:
pic_fprintf(pic, port, "#f");
break;
case PIC_TYPE_ID:
pic_fprintf(pic, port, "#<identifier %s>", pic_str(pic, pic_id_name(pic, obj)));
break;
case PIC_TYPE_EOF:
pic_fprintf(pic, port, "#.(eof-object)");
break;
case PIC_TYPE_INT:
pic_fprintf(pic, port, "%d", pic_int(pic, obj));
break;
case PIC_TYPE_SYMBOL:
pic_fprintf(pic, port, "%s", pic_sym(pic, obj));
break;
case PIC_TYPE_FLOAT:
write_float(pic, obj, port);
break;
case PIC_TYPE_BLOB:
write_blob(pic, obj, port);
break;
case PIC_TYPE_CHAR:
write_char(pic, obj, port, p);
break;
case PIC_TYPE_STRING:
write_str(pic, obj, port, p);
break;
case PIC_TYPE_PAIR:
write_pair(pic, obj, port, p);
break;
case PIC_TYPE_VECTOR:
write_vec(pic, obj, port, p);
break;
case PIC_TYPE_DICT:
write_dict(pic, obj, port, p);
break;
default:
pic_fprintf(pic, port, "#<%s %p>", pic_typename(pic, pic_type(pic, obj)), pic_obj_ptr(obj));
break;
}
if (p->op == OP_WRITE) {
if (is_shared_object(pic, obj, p)) {
pic_weak_del(pic, labels, obj);
}
}
}
void write(FILE *out, object *obj) {
char c;
char *str;
switch (obj->type) {
case THE_EMPTY_LIST:
fprintf(out, "()");
break;
case BOOLEAN:
fprintf(out, "%c", is_false(obj) ? 'f' : 't');
break;
case SYMBOL:
fprintf(out, "%s", obj->data.symbol.value);
break;
case FIXNUM:
fprintf(out, "%ld", obj->data.fixnum.value);
break;
case FLOATNUM:
fprintf(out, "%f", obj->data.floatnum.value);
break;
case CHARACTER:
c = obj->data.character.value;
fprintf(out, "#\\");
switch (c) {
case '\n':
fprintf(out, "newline");
break;
case ' ':
fprintf(out, "space");
break;
default:
putc(c, out);
}
break;
case STRING:
str = obj->data.string.value;
putc('"', out);
while (*str != '\0') {
switch (*str) {
case '\n':
fprintf(out, "\\n");
break;
case '\\':
fprintf(out, "\\\\");
break;
case '"':
fprintf(out, "\\\"");
break;
default:
putc(*str, out);
}
str++;
}
putc('"', out);
break;
case PAIR:
fprintf(out, "(");
write_pair(out, obj);
fprintf(out, ")");
break;
case PRIMITIVE_PROC:
fprintf(out, "#<primitive-procedure>");
break;
case COMPOUND_PROC:
fprintf(out, "#<compound-procedure>");
break;
case INPUT_PORT:
fprintf(out, "#<input-port>");
break;
case OUTPUT_PORT:
fprintf(out, "#<output-port>");
break;
case EOF_OBJECT:
fprintf(out, "#<eof>");
break;
default:
fprintf(stderr, "cannot write unknown type");
exit(1);
}
}
void query_update::write(const char *id, const std::string &x)
{
write_pair(id, type_text, x);
}
void query_update::write(const char *id, unsigned char x)
{
write_pair(id, type_unsigned_char, x);
}
void query_update::write(const char *id, float x)
{
write_pair(id, type_float, x);
}
/* add a lastError message on the end of the buffer.
* returns 0 on failure */
static int add_last_error(PyObject* self, buffer_t buffer,
int request_id, char* ns, int nslen, PyObject* args) {
struct module_state *state = GETSTATE(self);
int message_start;
int document_start;
int message_length;
int document_length;
PyObject* key;
PyObject* value;
Py_ssize_t pos = 0;
PyObject* one;
char *p = strchr(ns, '.');
/* Length of the database portion of ns. */
nslen = p ? (int)(p - ns) : nslen;
message_start = buffer_save_space(buffer, 4);
if (message_start == -1) {
PyErr_NoMemory();
return 0;
}
if (!buffer_write_bytes(buffer, (const char*)&request_id, 4) ||
!buffer_write_bytes(buffer,
"\x00\x00\x00\x00" /* responseTo */
"\xd4\x07\x00\x00" /* opcode */
"\x00\x00\x00\x00", /* options */
12) ||
!buffer_write_bytes(buffer,
ns, nslen) || /* database */
!buffer_write_bytes(buffer,
".$cmd\x00" /* collection name */
"\x00\x00\x00\x00" /* skip */
"\xFF\xFF\xFF\xFF", /* limit (-1) */
14)) {
return 0;
}
/* save space for length */
document_start = buffer_save_space(buffer, 4);
if (document_start == -1) {
PyErr_NoMemory();
return 0;
}
/* getlasterror: 1 */
if (!(one = PyLong_FromLong(1)))
return 0;
if (!write_pair(state->_cbson, buffer, "getlasterror", 12, one, 0, 4, 1)) {
Py_DECREF(one);
return 0;
}
Py_DECREF(one);
/* getlasterror options */
while (PyDict_Next(args, &pos, &key, &value)) {
if (!decode_and_write_pair(state->_cbson, buffer, key, value, 0, 4, 0)) {
return 0;
}
}
/* EOD */
if (!buffer_write_bytes(buffer, "\x00", 1)) {
return 0;
}
message_length = buffer_get_position(buffer) - message_start;
document_length = buffer_get_position(buffer) - document_start;
memcpy(buffer_get_buffer(buffer) + message_start, &message_length, 4);
memcpy(buffer_get_buffer(buffer) + document_start, &document_length, 4);
return 1;
}
void write(obj_t obj) {
char c;
char *str;
if (obj == imm_empty_list) {
printf("()");
} else if (is_pair(obj)) {
printf("(");
write_pair(obj);
printf(")");
} else if (is_symbol(obj)) {
printf("%s", unwrap_symbol(obj)->value);
} else if (is_string(obj)) {
printf("\"%s\"", unwrap_string(obj)->value);
} else if (is_boolean(obj)) {
printf("#%c", obj==imm_false ? 'f' : 't');
} else if (is_fixnum(obj)) {
printf("%lld", unwrap_fixnum(obj));
} else if (is_thunk(obj)) {
printf("#<thunk>");
} else if (is_primitive_proc(obj)) {
printf("#<primitive fn>");
} else if (obj == imm_undefined) {
printf("#<undefined>");
} else {
assert(0);
}
#if 0
case SYMBOL:
printf("%s", obj->data.symbol->value);
break;
case FIXNUM:
printf("%ld", obj->data.fixnum);
break;
case CHARACTER:
c = obj->data.character;
printf("#\\");
switch (c) {
case '\n':
printf("newline");
break;
case ' ':
printf("space");
break;
default:
putchar(c);
}
break;
case STRING:
str = obj->data.string->value;
putchar('"');
while (*str != '\0') {
switch (*str) {
case '\n':
printf("\\n");
break;
case '\\':
printf("\\\\");
break;
case '"':
printf("\\\"");
break;
default:
putchar(*str);
}
str++;
}
putchar('"');
break;
case PAIR:
printf("(");
write_pair(obj);
printf(")");
break;
case PRIMITIVE_PROC:
case COMPOUND_PROC:
printf("#<procedure>");
break;
default:
fprintf(stderr, "cannot write unknown type\n");
exit(1);
}
void query_update::write(const char *id, double x)
{
write_pair(id, type_double, x);
}
void query_update::write(const char *id, char x)
{
write_pair(id, type_char, x);
}
void query_update::write(const char *id, const char *x, int)
{
write_pair(id, type_char_pointer, x);
}
void query_update::write(const char *id, const object_base_ptr &x)
{
write_pair(id, type_long, x.id());
}
void query_update::write(const char *id, short x)
{
write_pair(id, type_short, x);
}
void query_update::write(const char *id, unsigned long x)
{
write_pair(id, type_unsigned_long, x);
}
void write(FILE *out, object *obj) {
char *str = NULL;
char str2[5];
switch (obj->type) {
case BOOLEAN:
fprintf(out, "#%c", is_false(obj) ? 'f' : 't');
break;
case CHARACTER:
str2[0] = '\0';
expand_esc_seq(str2, obj->data.character.value);
fprintf(out, "#'%s'", str2);
break;
case COMPOUND_PROC:
fprintf(out, "#<compound-procedure>");
break;
case EMPTY_LIST:
fprintf(out, "()");
break;
case EOF_OBJECT:
fprintf(out, "#<eof>");
break;
case FIXNUM:
fprintf(out, "%ld", obj->data.fixnum.value);
break;
case FLOATNUM:
fprintf(out, "%f", obj->data.floatnum.value);
break;
case INPUT_PORT:
fprintf(out, "#<input-port>");
break;
case OUTPUT_PORT:
fprintf(out, "#<output-port>");
break;
case PAIR:
fprintf(out, "(");
write_pair(out, obj);
fprintf(out, ")");
break;
case PRIMITIVE_PROC:
fprintf(out, "#<primitive-procedure>");
break;
case STRING:
str = obj->data.string.value;
fputc('"', out);
while (*str != '\0') {
str2[0] = '\0';
expand_esc_seq(str2, *str);
fprintf(out, "%s", str2);
str++;
}
fputc('"', out);
break;
case SYMBOL:
fprintf(out, "%s", obj->data.symbol.value);
break;
case ERROR:
fprintf(out, "Error %ld: %s", obj->data.error.error_num, obj->data.error.error_msg);
break;
default:
fprintf(stderr, "cannot write unknown type\n");
exit(EXIT_FAILURE);
} // switch
} // write()
void query_update::write(const char *id, unsigned int x)
{
write_pair(id, type_unsigned_int, x);
}
void slip_write(pSlip gd, pSlipObject obj)
{
if (gd->running != SLIP_RUNNING || obj == NULL)
return;
switch (obj->type)
{
case eType_PRIMITIVE_PROC:
case eType_COMPOUND_PROC:
printf("#<procedure> %p", obj->data.prim_proc.func);
break;
case eType_EMPTY_LIST:
printf("()");
break;
case eType_PAIR:
printf("(");
write_pair(gd, obj);
printf(")");
break;
case eType_SYMBOL:
printf("%s", obj->data.symbol.value);
break;
case eType_INTNUM:
printf("%"PRIi64, obj->data.intnum.value);
break;
case eType_NIL:
printf("<NIL>");
break;
case eType_BOOL:
printf("#%c", obj == gd->singleton_True ? 't' : 'f');
break;
case eType_STRING:
{
char *str;
str = obj->data.string.data;
printf("\"");
while (*str != '\0')
{
switch (*str)
{
case '\n':
printf("\\n");
break;
case '\\':
printf("\\\\");
break;
case '"':
printf("\\\"");
break;
default:
printf("%c", *str);
break;
}
str++;
}
printf("\"");
}
break;
case eType_CHARACTER:
printf("#\\");
switch (obj->data.character.value)
{
case '\t':
printf("tab");
break;
case '\n':
printf("newline");
break;
case ' ':
printf("space");
break;
default:
printf("%c", obj->data.character.value);
break;
}
break;
default:
throw_error(gd, "cannot eval unknown expression type\n");
break;
}
}
void query_update::write(const char *id, const varchar_base &x)
{
write_pair(id, type_varchar, x);
}
