void sccp_dev_statusprompt_set(sccp_device_t * d, sccp_channel_t * c, char * msg, int timeout) { sccp_moo_t * r; if (!d->session) return; if (msg == NULL) { REQ(r, ClearPromptStatusMessage) r->msg.ClearPromptStatusMessage.callReference = (c) ? c->callid : 0; r->msg.ClearPromptStatusMessage.lineInstance = (c) ? c->line->instance : 0; } else { REQ(r, DisplayPromptStatusMessage) r->msg.DisplayPromptStatusMessage.messageTimeout = timeout; r->msg.DisplayPromptStatusMessage.callReference = (c) ? c->callid : 0; r->msg.DisplayPromptStatusMessage.lineInstance = (c) ? c->line->instance : 0; strncpy(r->msg.DisplayPromptStatusMessage.promptMessage, msg, sizeof(r->msg.DisplayPromptStatusMessage.promptMessage) - 1); } sccp_dev_send(d, r); }
static void compile_rhs(labellist *ll, nfa *nf, node *n, int *pa, int *pb) { int i; int a, b; REQ(n, RHS); i = n->n_nchildren; REQN(i, 1); n = n->n_child; REQ(n, ALT); compile_alt(ll, nf, n, pa, pb); if (--i <= 0) return; n++; a = *pa; b = *pb; *pa = addnfastate(nf); *pb = addnfastate(nf); addnfaarc(nf, *pa, a, EMPTY); addnfaarc(nf, b, *pb, EMPTY); for (; --i >= 0; n++) { REQ(n, VBAR); REQN(i, 1); --i; n++; REQ(n, ALT); compile_alt(ll, nf, n, &a, &b); addnfaarc(nf, *pa, a, EMPTY); addnfaarc(nf, b, *pb, EMPTY); } }
static void compile_atom(labellist *ll, nfa *nf, node *n, int *pa, int *pb) { int i; REQ(n, ATOM); i = n->n_nchildren; (void)i; /* Don't warn about set but unused */ REQN(i, 1); n = n->n_child; if (n->n_type == LPAR) { REQN(i, 3); n++; REQ(n, RHS); compile_rhs(ll, nf, n, pa, pb); n++; REQ(n, RPAR); } else if (n->n_type == NAME || n->n_type == STRING) { *pa = addnfastate(nf); *pb = addnfastate(nf); addnfaarc(nf, *pa, *pb, addlabel(ll, n->n_type, n->n_str)); } else REQ(n, NAME); }
void sccp_dev_set_sptone_byid(sccp_device_t * d, int tone) { sccp_moo_t * r; if (!d->session) return; if (d->currentTone == tone) { if (sccp_debug) ast_verbose(VERBOSE_PREFIX_3 "Current tone (%d) is equiv to wanted tone (%d). Ignoring.\n", d->currentTone, tone); return; } if (sccp_debug) ast_verbose(VERBOSE_PREFIX_3 "Sending tone %d\n", tone); if (tone > 0) { REQ(r, StartToneMessage) r->msg.StartToneMessage.tone = tone; } else { REQ(r, StopToneMessage) } sccp_dev_send(d, r); d->currentTone = tone; }
object_t *lisp_print (object_t * lst) { DOC ("Print object or sexp in parse-able form."); REQ (lst, 1, c_sym ("print")); obj_print (CAR (lst), 1); return NIL; }
object_t *numberp (object_t * lst) { DOC ("Return t if object is a number."); REQ (lst, 1, c_sym ("numberp")); if (NUMP (CAR (lst))) return T; return NIL; }
object_t *symbolp (object_t * lst) { DOC ("Return t if object is a symbol."); REQ (lst, 1, c_sym ("symbolp")); if (SYMBOLP (CAR (lst))) return T; return NIL; }
object_t *listp (object_t * lst) { DOC ("Return t if object is a list."); REQ (lst, 1, c_sym ("listp")); if (LISTP (CAR (lst))) return T; return NIL; }
object_t *funcp (object_t * lst) { DOC ("Return t if object is a function."); REQ (lst, 1, c_sym ("funcp")); if (FUNCP (CAR (lst))) return T; return NIL; }
object_t *nullp (object_t * lst) { DOC ("Return t if object is nil."); REQ (lst, 1, c_sym ("nullp")); if (CAR (lst) == NIL) return T; return NIL; }
object_t *symbol_name (object_t * lst) { DOC ("Return symbol name as string."); REQ (lst, 1, c_sym ("symbol-name")); if (!SYMBOLP (CAR (lst))) THROW (wrong_type, UPREF (CAR (lst))); return c_strs (xstrdup (SYMNAME (CAR (lst)))); }
object_t *stringp (object_t * lst) { DOC ("Return t if object is a string."); REQ (lst, 1, c_sym ("stringp")); if (STRINGP (CAR (lst))) return T; return NIL; }
object_t *floatp (object_t * lst) { DOC ("Return t if object is a floating-point number."); REQ (lst, 1, c_sym ("floatp")); if (FLOATP (CAR (lst))) return T; return NIL; }
object_t *vectorp (object_t * lst) { DOC ("Return t if object is a vector."); REQ (lst, 1, c_sym ("vectorp")); if (VECTORP (CAR (lst))) return T; return NIL; }
object_t *integerp (object_t * lst) { DOC ("Return t if object is an integer."); REQ (lst, 1, c_sym ("integerp")); if (INTP (CAR (lst))) return T; return NIL; }
static int neigh_filter(struct nl_common *obj, struct nl_common *filter) { struct rtnl_neigh *o = (struct rtnl_neigh *) obj; struct rtnl_neigh *f = (struct rtnl_neigh *) filter; if (obj->ce_type != RTNL_NEIGH || filter->ce_type != RTNL_NEIGH) return 0; #define REQ(F) (f->n_mask & NEIGH_HAS_##F) #define AVAIL(F) (o->n_mask & NEIGH_HAS_##F) if ((REQ(IFINDEX) && (!AVAIL(IFINDEX) || o->n_ifindex != f->n_ifindex)) || (REQ(FAMILY) && (!AVAIL(FAMILY) || o->n_family != f->n_family)) || (REQ(TYPE) && (!AVAIL(TYPE) || o->n_type != f->n_type)) || (REQ(LLADDR) && (!AVAIL(LLADDR) || nl_addrcmp(&o->n_lladdr, &f->n_lladdr))) || (REQ(DST) && (!AVAIL(DST) || nl_addrcmp(&o->n_dst, &f->n_dst))) || (REQ(STATE) && (!AVAIL(STATE) || f->n_state ^ (o->n_state & f->n_state_mask))) || (REQ(FLAGS) && (!AVAIL(FLAGS) || f->n_flags ^ (o->n_flags & f->n_flag_mask)))) return 0; #undef REQ #undef AVAIL return 1; }
object_t *lisp_value (object_t * lst) { DOC ("Get value stored in symbol."); REQ (lst, 1, c_sym ("value")); if (!SYMBOLP (CAR (lst))) THROW (wrong_type, c_cons (c_sym ("value"), CAR (lst))); return UPREF (GET (CAR (lst))); }
static void compile_rule(nfagrammar *gr, node *n) { nfa *nf; REQ(n, RULE); REQN(n->n_nchildren, 4); n = n->n_child; REQ(n, NAME); nf = addnfa(gr, n->n_str); n++; REQ(n, COLON); n++; REQ(n, RHS); compile_rhs(&gr->gr_ll, nf, n, &nf->nf_start, &nf->nf_finish); n++; REQ(n, NEWLINE); }
object_t *eq (object_t * lst) { DOC ("Return t if both arguments are the same lisp object."); REQ (lst, 2, c_sym ("eq")); object_t *a = CAR (lst); object_t *b = CAR (CDR (lst)); if (a == b) return T; return NIL; }
object_t *lisp_car (object_t * lst) { DOC ("Return car element of cons cell."); REQ (lst, 1, c_sym ("car")); if (CAR (lst) == NIL) return NIL; if (!LISTP (CAR (lst))) THROW (wrong_type, CAR (lst)); return UPREF (CAR (CAR (lst))); }
object_t *lisp_apply (object_t * lst) { DOC ("Apply function to a list."); REQ (lst, 2, c_sym ("apply")); object_t *f = CAR (lst); object_t *args = CAR (CDR (lst)); if (!LISTP (args)) THROW (wrong_type, UPREF (args)); return apply (f, args); }
void sccp_dev_set_speaker(sccp_device_t * d, StationSpeakerMode mode) { sccp_moo_t * r; if (!d->session) return; REQ(r, SetSpeakerModeMessage) r->msg.SetSpeakerModeMessage.speakerMode = mode; ast_verbose(VERBOSE_PREFIX_2 "{SetSpeakerModeMessage} speakerMode=%d\n", mode); sccp_dev_send(d, r); }
void sccp_dev_set_microphone(sccp_device_t * d, StationMicrophoneMode opt) { sccp_moo_t * r; if (!d->session) return; REQ(r, SetMicroModeMessage) r->msg.SetMicroModeMessage.micMode = opt; ast_verbose(VERBOSE_PREFIX_2 "{SetMicroModeMessage} micMode=%d\n", opt); sccp_dev_send(d, r); }
static void compile_alt(labellist *ll, nfa *nf, node *n, int *pa, int *pb) { int i; int a, b; REQ(n, ALT); i = n->n_nchildren; REQN(i, 1); n = n->n_child; REQ(n, ITEM); compile_item(ll, nf, n, pa, pb); --i; n++; for (; --i >= 0; n++) { REQ(n, ITEM); compile_item(ll, nf, n, &a, &b); addnfaarc(nf, *pb, a, EMPTY); *pb = b; } }
object_t *lisp_set (object_t * lst) { DOC ("Store object in symbol."); REQ (lst, 2, c_sym ("set")); if (!SYMBOLP (CAR (lst))) THROW (wrong_type, c_cons (c_sym ("set"), CAR (lst))); if (CONSTANTP (CAR (lst))) THROW (c_sym ("setting-constant"), CAR (lst)); SET (CAR (lst), CAR (CDR (lst))); return UPREF (CAR (CDR (lst))); }
object_t *lisp_concat (object_t * lst) { DOC ("Concatenate two strings."); REQ (lst, 2, c_sym ("concat")); object_t *a = CAR (lst); object_t *b = CAR (CDR (lst)); if (!STRINGP (a)) THROW (wrong_type, UPREF (a)); if (!STRINGP (b)) THROW (wrong_type, UPREF (b)); return str_cat (a, b); }
object_t *lisp_load (object_t * lst) { DOC ("Evaluate contents of a file."); REQ (lst, 1, c_sym ("load")); object_t *str = CAR (lst); if (!STRINGP (str)) THROW (wrong_type, UPREF (str)); char *filename = OSTR (str); int r = load_file (NULL, filename, 0); if (!r) THROW (c_sym ("load-file-error"), UPREF (str)); return T; }
static int future_check_features(PyFutureFeatures *ff, node *n, const char *filename) { int i; char *feature; node *ch, *nn; REQ(n, import_from); nn = CHILD(n, 3 + (TYPE(CHILD(n, 3)) == LPAR)); if (TYPE(nn) == STAR) { PyErr_SetString(PyExc_SyntaxError, FUTURE_IMPORT_STAR); PyErr_SyntaxLocation(filename, nn->n_lineno); return -1; } REQ(nn, import_as_names); for (i = 0; i < NCH(nn); i += 2) { ch = CHILD(nn, i); REQ(ch, import_as_name); feature = STR(CHILD(ch, 0)); if (strcmp(feature, FUTURE_NESTED_SCOPES) == 0) { continue; } else if (strcmp(feature, FUTURE_GENERATORS) == 0) { continue; } else if (strcmp(feature, FUTURE_DIVISION) == 0) { ff->ff_features |= CO_FUTURE_DIVISION; } else if (strcmp(feature, "braces") == 0) { PyErr_SetString(PyExc_SyntaxError, "not a chance"); PyErr_SyntaxLocation(filename, CHILD(ch, 0)->n_lineno); return -1; } else { PyErr_Format(PyExc_SyntaxError, UNDEFINED_FUTURE_FEATURE, feature); PyErr_SyntaxLocation(filename, CHILD(ch, 0)->n_lineno); return -1; } } return 0; }
static void compile_item(labellist *ll, nfa *nf, node *n, int *pa, int *pb) { int i; int a, b; REQ(n, ITEM); i = n->n_nchildren; REQN(i, 1); n = n->n_child; if (n->n_type == LSQB) { REQN(i, 3); n++; REQ(n, RHS); *pa = addnfastate(nf); *pb = addnfastate(nf); addnfaarc(nf, *pa, *pb, EMPTY); compile_rhs(ll, nf, n, &a, &b); addnfaarc(nf, *pa, a, EMPTY); addnfaarc(nf, b, *pb, EMPTY); REQN(i, 1); n++; REQ(n, RSQB); } else { compile_atom(ll, nf, n, pa, pb); if (--i <= 0) return; n++; addnfaarc(nf, *pb, *pa, EMPTY); if (n->n_type == STAR) *pb = *pa; else REQ(n, PLUS); } }
object_t *lisp_read_string (object_t * lst) { DOC ("Parse a string into a sexp or list object."); REQ (lst, 1, c_sym ("eval-string")); object_t *stro = CAR (lst); if (!STRINGP (stro)) THROW (wrong_type, UPREF (stro)); char *str = OSTR (stro); reader_t *r = reader_create (NULL, str, "eval-string", 0); object_t *sexp = read_sexp (r); reader_destroy (r); if (sexp == err_symbol) THROW (c_sym ("parse-error"), UPREF (stro)); return sexp; }