// ParseModeLine parses a line of mode changes into core.DataChange structs. // Redundant changes are compressed down into one. // An error is returned if unknown modes are encountered, or modes are dropped // due to missing parameters. The remainder of the modes are still parsed. // e is the user or channel being changed. func (p *ModeParser) ParseModeLine(source *core.User, e core.Extensible, modeline []byte, params []string) ([]core.DataChange, os.Error) { var adding bool = true var unknown string var missing string var param int modes := string(modeline) changes := make(map[string]core.DataChange) for _, char := range modes { if char == '+' { adding = true continue } else if char == '-' { adding = false continue } if v, ok := p.simple[char]; ok { if v, ok := p.extended[char]; ok { newchanges := v(adding, e, "") for _, it := range newchanges { changes[it.Name] = it } continue } var change core.DataChange change.Name = v if adding { change.Data = "on" } changes[change.Name] = change continue } if v, ok := p.parametered[char]; ok { var change core.DataChange if adding { if param >= len(params) { missing += string(char) continue } if v, ok := p.extended[char]; ok { newch := v(adding, e, params[param]) param++ for _, it := range newch { changes[it.Name] = it } continue } change.Name = v change.Data = params[param] param++ } else { if v, ok := p.extended[char]; ok { newchanges := v(adding, e, "") for _, it := range newchanges { changes[it.Name] = it } continue } change.Name = v } changes[change.Name] = change continue } if v, ok := p.list[char]; ok { if param >= len(params) { missing += string(char) continue } var change core.DataChange cparam := params[param] param++ if v, ok := p.extended[char]; ok { newchanges := v(adding, e, cparam) for _, it := range newchanges { if it.Data != "" { it.Data += fmt.Sprintf(" setby-%s setat-%d", source.GetSetBy(), time.Seconds()) } changes[it.Name] = it } continue } if adding { change.Name = v + " " + cparam change.Data = fmt.Sprintf("on setby-%s setat-%d", source.GetSetBy(), time.Seconds()) } else { change.Name = v + " " + cparam } changes[change.Name] = change continue } if v, ok := p.membership[char]; ok { var ch *core.Channel var ok bool if ch, ok = e.(*core.Channel); !ok { continue } if param >= len(params) { missing += string(char) continue } par := params[param] param++ if v, ok := p.extended[char]; ok { newchanges := v(adding, e, par) for _, it := range newchanges { if it.Member != nil { changes["m"+it.Member.User().ID()+" "+it.Name] = it } else { changes[it.Name] = it } } continue } var u *core.User var m *core.Membership if u = core.GetUser(par); u == nil { if u = core.GetUserByNick(par); u == nil { continue } } if m = ch.GetMember(u); m == nil { continue } var change core.DataChange change.Name = v change.Member = m if adding { change.Data = "on" } changes["m"+change.Member.User().ID()+" "+change.Name] = change continue } unknown += string(char) } // Turn the modes into a slice. c := make([]core.DataChange, 0, len(changes)) for _, change := range changes { c = append(c, change) } // Get the error, if we had one. var errstring string if unknown != "" { errstring += "Unknown mode letters: " + unknown if missing != "" { errstring += " " } } if missing != "" { errstring += "Missing parameters for: " + missing } var err os.Error if errstring != "" { err = os.NewError(errstring) } return c, err }