bu_ptr operator()(double duration, PyObject * list)
{
if (duration != 0) throw std::runtime_error("amp_mod with explicit duration");
const int n = PyList_Size(list);
if (n != 2) throw std::runtime_error("amp_mod requires 2 notes");
return U<am>(
parse_note(PyList_GetItem(list, 0)),
parse_note(PyList_GetItem(list, 1)));
}
note_sequence(settings &set) {
if (set.note_mode() == settings::note_mode_list) {
impl_.reset(new detail::listed_sqeuence(
set.concert_pitch(),
set.note_list().begin(), set.note_list().end(),
set.note_list().size()));
}
else {
assert(set.note_mode() == settings::note_mode_start);
trc("using a start note and distance");
int start_offset = parse_note(set.start_note().c_str());
int stop_offset;
if (! set.end_note().empty()) {
stop_offset = parse_note(set.end_note().c_str());
}
else if (set.num_notes() >= 0) {
stop_offset = start_offset + set.num_notes() * set.note_distance();
}
else {
stop_offset = start_offset + 12;
}
int step = set.note_distance();
if (start_offset > stop_offset && step > 0) {
std::cerr << "warning: making the step negative since the end note is lower than the start note." << std::endl;
step = -step;
}
else if (start_offset < stop_offset && step < 0) {
std::cerr << "warning: making the step positive since the end note is higher than the start note." << std::endl;
step = -step;
}
trc("start: " << start_offset);
trc("stop: " << stop_offset);
trc("step: " << step);
impl_.reset(
new detail::generated_sequence(
set.concert_pitch(), start_offset, stop_offset, step
)
);
trc("done");
assert(impl_.get());
}
}
listed_sqeuence(double concert_pitch, InputIterator begin, InputIterator end, std::size_t reserve = 0) {
frequencies_.reserve(reserve);
while (begin != end) {
if (is_floating_point<typename InputIterator::value_type>(*begin)) {
double f = boost::lexical_cast<double>(*begin);
frequencies_.push_back(f);
}
else {
int offset = parse_note(begin->c_str());
frequencies_.push_back(offset_to_frequency(concert_pitch, offset));
}
++begin;
}
iter_ = frequencies_.begin();
}
bu_ptr operator()(double duration, PyObject * list)
{
if (duration == 0) throw std::runtime_error("freq_mod misses duration");
PyObject * head = PyList_GetItem(list, 0);
bu_ptr m = parse_note(head, duration);
const params p = parse_params("?++@@", list, 1);
en_ptr index = mk_envelope(p[2]);
en_ptr carrier = mk_envelope(p[3]);
en_ptr i = P<stretched>(index, duration);
en_ptr c = P<stretched>(carrier, duration);
return U<sound>(U<fm>(std::move(m), duration, i, c),
duration,
make_stroke(P<punctual>(0, p[0].get()),
p[1].get() / p[3].get(), duration));
}
/*
Format:
<Note><Octave><Duration>
Note: C, Db, D, ...
Octave: [1..8]
Duration: 1, 2, 4, ... - semibreve, half, quarter, ...
*/
void play_token(const char *tok, int len, WaveFile *wav) {
tnote note;
int octave;
float duration;
note = parse_note(tok[0]);
octave = tok[1] - '0';
if (tok[1] == 'b') {
--note;
octave = tok[2] - '0';
duration = (float)(tok[3] - '0');
} else if (tok[1] == '#') {
++note;
octave = tok[2] - '0';
duration = (float)(tok[3] - '0');
} else
duration = (float)(tok[2] - '0');
duration = 1.0 / duration;
// fprintf(stderr, "Note: %d; Octave: %d; Duration: %f\n", note, octave, duration);
play_note(note, octave, duration, wav);
}
grub_err_t
grub_xen_get_infoXX (grub_elf_t elf, struct grub_xen_file_info *xi)
{
Elf_Shdr *s, *s0;
grub_size_t shnum = elf->ehdr.ehdrXX.e_shnum;
grub_size_t shentsize = elf->ehdr.ehdrXX.e_shentsize;
grub_size_t shsize = shnum * shentsize;
grub_off_t stroff;
grub_err_t err;
Elf_Phdr *phdr;
xi->kern_end = 0;
xi->kern_start = ~0;
xi->entry_point = elf->ehdr.ehdrXX.e_entry;
/* FIXME: check note. */
FOR_ELF_PHDRS (elf, phdr)
{
Elf_Addr paddr;
if (phdr->p_type == PT_NOTE)
{
err = parse_note (elf, xi, phdr->p_offset, phdr->p_filesz);
if (err)
return err;
}
if (phdr->p_type != PT_LOAD)
continue;
paddr = phdr->p_paddr;
if (paddr < xi->kern_start)
xi->kern_start = paddr;
if (paddr + phdr->p_memsz > xi->kern_end)
xi->kern_end = paddr + phdr->p_memsz;
}
static void
parse_named_action(enum ofputil_action_code code,
char *arg, struct ofpbuf *ofpacts)
{
struct ofpact_tunnel *tunnel;
uint16_t vid;
uint16_t ethertype;
ovs_be32 ip;
uint8_t pcp;
uint8_t tos;
switch (code) {
case OFPUTIL_ACTION_INVALID:
NOT_REACHED();
case OFPUTIL_OFPAT10_OUTPUT:
case OFPUTIL_OFPAT11_OUTPUT:
parse_output(arg, ofpacts);
break;
case OFPUTIL_OFPAT10_SET_VLAN_VID:
case OFPUTIL_OFPAT11_SET_VLAN_VID:
vid = str_to_u32(arg);
if (vid & ~VLAN_VID_MASK) {
ovs_fatal(0, "%s: not a valid VLAN VID", arg);
}
ofpact_put_SET_VLAN_VID(ofpacts)->vlan_vid = vid;
break;
case OFPUTIL_OFPAT10_SET_VLAN_PCP:
case OFPUTIL_OFPAT11_SET_VLAN_PCP:
pcp = str_to_u32(arg);
if (pcp & ~7) {
ovs_fatal(0, "%s: not a valid VLAN PCP", arg);
}
ofpact_put_SET_VLAN_PCP(ofpacts)->vlan_pcp = pcp;
break;
case OFPUTIL_OFPAT12_SET_FIELD:
set_field_parse(arg, ofpacts);
break;
case OFPUTIL_OFPAT10_STRIP_VLAN:
case OFPUTIL_OFPAT11_POP_VLAN:
ofpact_put_STRIP_VLAN(ofpacts);
break;
case OFPUTIL_OFPAT11_PUSH_VLAN:
ethertype = str_to_u16(arg, "ethertype");
if (ethertype != ETH_TYPE_VLAN_8021Q) {
/* XXX ETH_TYPE_VLAN_8021AD case isn't supported */
ovs_fatal(0, "%s: not a valid VLAN ethertype", arg);
}
ofpact_put_PUSH_VLAN(ofpacts);
break;
case OFPUTIL_OFPAT11_SET_QUEUE:
ofpact_put_SET_QUEUE(ofpacts)->queue_id = str_to_u32(arg);
break;
case OFPUTIL_OFPAT10_SET_DL_SRC:
case OFPUTIL_OFPAT11_SET_DL_SRC:
str_to_mac(arg, ofpact_put_SET_ETH_SRC(ofpacts)->mac);
break;
case OFPUTIL_OFPAT10_SET_DL_DST:
case OFPUTIL_OFPAT11_SET_DL_DST:
str_to_mac(arg, ofpact_put_SET_ETH_DST(ofpacts)->mac);
break;
case OFPUTIL_OFPAT10_SET_NW_SRC:
case OFPUTIL_OFPAT11_SET_NW_SRC:
str_to_ip(arg, &ip);
ofpact_put_SET_IPV4_SRC(ofpacts)->ipv4 = ip;
break;
case OFPUTIL_OFPAT10_SET_NW_DST:
case OFPUTIL_OFPAT11_SET_NW_DST:
str_to_ip(arg, &ip);
ofpact_put_SET_IPV4_DST(ofpacts)->ipv4 = ip;
break;
case OFPUTIL_OFPAT10_SET_NW_TOS:
case OFPUTIL_OFPAT11_SET_NW_TOS:
tos = str_to_u32(arg);
if (tos & ~IP_DSCP_MASK) {
ovs_fatal(0, "%s: not a valid TOS", arg);
}
ofpact_put_SET_IPV4_DSCP(ofpacts)->dscp = tos;
break;
case OFPUTIL_OFPAT11_DEC_NW_TTL:
NOT_REACHED();
case OFPUTIL_OFPAT10_SET_TP_SRC:
case OFPUTIL_OFPAT11_SET_TP_SRC:
ofpact_put_SET_L4_SRC_PORT(ofpacts)->port = str_to_u32(arg);
break;
case OFPUTIL_OFPAT10_SET_TP_DST:
case OFPUTIL_OFPAT11_SET_TP_DST:
ofpact_put_SET_L4_DST_PORT(ofpacts)->port = str_to_u32(arg);
break;
case OFPUTIL_OFPAT10_ENQUEUE:
parse_enqueue(arg, ofpacts);
break;
case OFPUTIL_NXAST_RESUBMIT:
parse_resubmit(arg, ofpacts);
break;
case OFPUTIL_NXAST_SET_TUNNEL:
case OFPUTIL_NXAST_SET_TUNNEL64:
tunnel = ofpact_put_SET_TUNNEL(ofpacts);
tunnel->ofpact.compat = code;
tunnel->tun_id = str_to_u64(arg);
break;
case OFPUTIL_NXAST_WRITE_METADATA:
parse_metadata(ofpacts, arg);
break;
case OFPUTIL_NXAST_SET_QUEUE:
ofpact_put_SET_QUEUE(ofpacts)->queue_id = str_to_u32(arg);
break;
case OFPUTIL_NXAST_POP_QUEUE:
ofpact_put_POP_QUEUE(ofpacts);
break;
case OFPUTIL_NXAST_REG_MOVE:
nxm_parse_reg_move(ofpact_put_REG_MOVE(ofpacts), arg);
break;
case OFPUTIL_NXAST_REG_LOAD:
nxm_parse_reg_load(ofpact_put_REG_LOAD(ofpacts), arg);
break;
case OFPUTIL_NXAST_NOTE:
parse_note(arg, ofpacts);
break;
case OFPUTIL_NXAST_MULTIPATH:
multipath_parse(ofpact_put_MULTIPATH(ofpacts), arg);
break;
case OFPUTIL_NXAST_BUNDLE:
bundle_parse(arg, ofpacts);
break;
case OFPUTIL_NXAST_BUNDLE_LOAD:
bundle_parse_load(arg, ofpacts);
break;
case OFPUTIL_NXAST_RESUBMIT_TABLE:
case OFPUTIL_NXAST_OUTPUT_REG:
case OFPUTIL_NXAST_DEC_TTL_CNT_IDS:
NOT_REACHED();
case OFPUTIL_NXAST_LEARN:
learn_parse(arg, ofpacts);
break;
case OFPUTIL_NXAST_EXIT:
ofpact_put_EXIT(ofpacts);
break;
case OFPUTIL_NXAST_DEC_TTL:
parse_dec_ttl(ofpacts, arg);
break;
case OFPUTIL_NXAST_SET_MPLS_TTL:
case OFPUTIL_OFPAT11_SET_MPLS_TTL:
parse_set_mpls_ttl(ofpacts, arg);
break;
case OFPUTIL_OFPAT11_DEC_MPLS_TTL:
case OFPUTIL_NXAST_DEC_MPLS_TTL:
ofpact_put_DEC_MPLS_TTL(ofpacts);
break;
case OFPUTIL_NXAST_FIN_TIMEOUT:
parse_fin_timeout(ofpacts, arg);
break;
case OFPUTIL_NXAST_CONTROLLER:
parse_controller(ofpacts, arg);
break;
case OFPUTIL_OFPAT11_PUSH_MPLS:
case OFPUTIL_NXAST_PUSH_MPLS:
ofpact_put_PUSH_MPLS(ofpacts)->ethertype =
htons(str_to_u16(arg, "push_mpls"));
break;
case OFPUTIL_OFPAT11_POP_MPLS:
case OFPUTIL_NXAST_POP_MPLS:
ofpact_put_POP_MPLS(ofpacts)->ethertype =
htons(str_to_u16(arg, "pop_mpls"));
break;
case OFPUTIL_NXAST_STACK_PUSH:
nxm_parse_stack_action(ofpact_put_STACK_PUSH(ofpacts), arg);
break;
case OFPUTIL_NXAST_STACK_POP:
nxm_parse_stack_action(ofpact_put_STACK_POP(ofpacts), arg);
break;
case OFPUTIL_NXAST_SAMPLE:
parse_sample(ofpacts, arg);
break;
}
}
void do_note(CHAR_DATA *ch,char *argument)
{
parse_note(ch,argument,NOTE_NOTE);
}
void do_changes(CHAR_DATA *ch,char *argument)
{
parse_note(ch,argument,NOTE_CHANGES);
}
void do_penalty(CHAR_DATA *ch,char *argument)
{
parse_note(ch,argument,NOTE_PENALTY);
}
void do_weddings(CHAR_DATA *ch,char *argument)
{
parse_note(ch,argument,NOTE_WEDDINGS);
}
void do_idea(CHAR_DATA *ch,char *argument)
{
parse_note(ch,argument,NOTE_IDEA);
}
static bool parse_line_v1 (RuleSet* rs, const char* line)
{
if (0 == strcmp (line, "forward-unmatched")) {
rs->forward_unmatched = true;
return true;
}
if (0 == strcmp (line, "match-all")) {
rs->match_all = true;
return true;
}
Rule r;
clear_rule (&r);
char *tmp, *fre, *prt;
int i = 0;
bool in_match = true;
tmp = fre = strdup (line);
for (prt = strtok (tmp, " "); prt; prt = strtok (NULL, " "), ++i) {
bool rv;
if (prt[0] == '#') {
break;
}
if (0 == strcmp (prt, "|")) {
if (i == 0 || !in_match) {
i = -1;
break;
}
in_match = false;
r.len = i;
i = -1; // continue bumps it
continue;
}
if (i >= MAX_MSG) {
i = -1;
break;
}
if (in_match) {
switch (i) {
case 0:
rv = parse_status (&r, prt);
break;
case 1:
r.match[i] = parse_note (prt); // TODO IFF note-status..
if (r.match[i] < 128) {
r.mask[i] = 0x7f;
rv = true;
break;
}
// no break - fall through
default:
rv = parse_match (&r, i, prt);
break;
}
} else {
switch (i) {
case 1:
r.tx_set[i] = parse_note (prt); // TODO IFF note-status..
if (r.tx_set[i] < 128) {
r.tx_mask[i] = 0x00;
rv = true;
break;
}
// no break - fall through
default:
rv = parse_replacement (&r, i, prt);
break;
}
}
if (!rv) {
i = -1;
break;
}
}
r.tx_len = i;
free (fre);
if (r.tx_len < 1 || r.tx_len > MAX_MSG || r.len < 1 || r.len > MAX_MSG || in_match) {
return false;
}
add_rule (rs, &r);
return true;
}
/*
* This parses NOTICEs that are sent from that wacky ircd we are connected
* to, and 'to' is guaranteed not to be a channel.
*/
static void parse_local_server_notice (const char *from, const char *to, const char *line)
{
int lastlog_level;
const char * f;
f = from;
if (!f || !*f)
if (!(f = get_server_itsname(from_server)))
f = get_server_name(from_server);
/* OPERator Notices */
if (!strncmp(line, "*** Notice -- ", 13))
{
if (!strncmp(line + 14, "Received KILL message for ", 26))
if (kill_message(f, line + 40))
return;
message_from(to, LOG_OPNOTE);
lastlog_level = set_lastlog_msg_level(LOG_OPNOTE);
if (!do_hook(OPER_NOTICE_LIST, "%s %s", f, line + 14))
return;
}
/* NOTEs */
else if (!strncmp(line, "Note", 4))
{
char *note_from = NULL;
char *point = NULL;
if (strlen(line) > 10)
{
/* Skip the "Note From" part */
note_from = LOCAL_COPY(line + 10);
if ((point = strchr(note_from, '!')))
{
*point++ = 0;
FromUserHost = line;
if ((point = strchr(FromUserHost, ' ')))
{
*point++ = 0;
parse_note(note_from, point);
}
FromUserHost = empty_string;
}
}
return;
}
lastlog_level = set_lastlog_msg_level(LOG_SNOTE);
message_from(to, LOG_SNOTE);
/* Check to see if the notice already has its own header... */
if (do_hook(GENERAL_NOTICE_LIST, "%s %s %s", f, to, line))
{
if (*line == '*' || *line == '#')
{
if (do_hook(SERVER_NOTICE_LIST, "%s %s", f, line))
put_it("%s", line);
}
else
if (do_hook(SERVER_NOTICE_LIST, "%s *** %s", f, line))
say("%s", line);
}
if (lastlog_level)
message_from(NULL, lastlog_level);
}
static void
parse_named_action(enum ofputil_action_code code, const struct flow *flow,
struct ofpbuf *b, char *arg)
{
struct ofp_action_dl_addr *oada;
struct ofp_action_vlan_pcp *oavp;
struct ofp_action_vlan_vid *oavv;
struct ofp_action_nw_addr *oana;
struct ofp_action_tp_port *oata;
switch (code) {
case OFPUTIL_OFPAT_OUTPUT:
parse_output(b, arg);
break;
case OFPUTIL_OFPAT_SET_VLAN_VID:
oavv = ofputil_put_OFPAT_SET_VLAN_VID(b);
oavv->vlan_vid = htons(str_to_u32(arg));
break;
case OFPUTIL_OFPAT_SET_VLAN_PCP:
oavp = ofputil_put_OFPAT_SET_VLAN_PCP(b);
oavp->vlan_pcp = str_to_u32(arg);
break;
case OFPUTIL_OFPAT_STRIP_VLAN:
ofputil_put_OFPAT_STRIP_VLAN(b);
break;
case OFPUTIL_OFPAT_SET_DL_SRC:
case OFPUTIL_OFPAT_SET_DL_DST:
oada = ofputil_put_action(code, b);
str_to_mac(arg, oada->dl_addr);
break;
case OFPUTIL_OFPAT_SET_NW_SRC:
case OFPUTIL_OFPAT_SET_NW_DST:
oana = ofputil_put_action(code, b);
str_to_ip(arg, &oana->nw_addr);
break;
case OFPUTIL_OFPAT_SET_NW_TOS:
ofputil_put_OFPAT_SET_NW_TOS(b)->nw_tos = str_to_u32(arg);
break;
case OFPUTIL_OFPAT_SET_TP_SRC:
case OFPUTIL_OFPAT_SET_TP_DST:
oata = ofputil_put_action(code, b);
oata->tp_port = htons(str_to_u32(arg));
break;
case OFPUTIL_OFPAT_ENQUEUE:
parse_enqueue(b, arg);
break;
case OFPUTIL_NXAST_RESUBMIT:
parse_resubmit(b, arg);
break;
case OFPUTIL_NXAST_SET_TUNNEL:
parse_set_tunnel(b, arg);
break;
case OFPUTIL_NXAST_SET_QUEUE:
ofputil_put_NXAST_SET_QUEUE(b)->queue_id = htonl(str_to_u32(arg));
break;
case OFPUTIL_NXAST_POP_QUEUE:
ofputil_put_NXAST_POP_QUEUE(b);
break;
case OFPUTIL_NXAST_REG_MOVE:
nxm_parse_reg_move(ofputil_put_NXAST_REG_MOVE(b), arg);
break;
case OFPUTIL_NXAST_REG_LOAD:
nxm_parse_reg_load(ofputil_put_NXAST_REG_LOAD(b), arg);
break;
case OFPUTIL_NXAST_NOTE:
parse_note(b, arg);
break;
case OFPUTIL_NXAST_SET_TUNNEL64:
ofputil_put_NXAST_SET_TUNNEL64(b)->tun_id = htonll(str_to_u64(arg));
break;
case OFPUTIL_NXAST_MULTIPATH:
multipath_parse(ofputil_put_NXAST_MULTIPATH(b), arg);
break;
case OFPUTIL_NXAST_AUTOPATH:
autopath_parse(ofputil_put_NXAST_AUTOPATH(b), arg);
break;
case OFPUTIL_NXAST_BUNDLE:
bundle_parse(b, arg);
break;
case OFPUTIL_NXAST_BUNDLE_LOAD:
bundle_parse_load(b, arg);
break;
case OFPUTIL_NXAST_RESUBMIT_TABLE:
case OFPUTIL_NXAST_OUTPUT_REG:
NOT_REACHED();
case OFPUTIL_NXAST_LEARN:
learn_parse(b, arg, flow);
break;
case OFPUTIL_NXAST_EXIT:
ofputil_put_NXAST_EXIT(b);
break;
}
}