HGKeeper

pidgin/purple-plugin-pack

remove the ignorance plugin as it's incomplete and unlikely to be completed

2020-03-01, Gary Kramlich

3764bea5cd05

Parents dc7b0c1e5035
Children ca8e25598f80

remove the ignorance plugin as it's incomplete and unlikely to be completed

23 files changed, 0 insertions(+), 9102 deletions(-)

+0 -10

ignorance/README.md

+0 -701

ignorance/callbacks.c

+0 -60

ignorance/callbacks.h

+0 -1209

ignorance/ignorance.c

+0 -20

ignorance/ignorance.conf

+0 -45

ignorance/ignorance.h

+0 -62

ignorance/ignorance_denizen.c

+0 -42

ignorance/ignorance_denizen.h

+0 -72

ignorance/ignorance_internal.h

+0 -328

ignorance/ignorance_level.c

+0 -99

ignorance/ignorance_level.h

+0 -243

ignorance/ignorance_rule.c

+0 -117

ignorance/ignorance_rule.h

+0 -45

ignorance/ignorance_violation.c

+0 -32

ignorance/ignorance_violation.h

+0 -284

ignorance/interface.c

+0 -48

ignorance/interface.h

+0 -26

ignorance/meson.build

+0 -4952

+0 -490

+0 -158

+0 -58

+0 -1

meson.build

~~--- a/ignorance/README.md Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,10 +0,0 @@

~~-# Ignorance~~

~~-status: incomplete~~

~~-dependencies: pidgin~~

~~-authors: Levi Bard~~

~~-introduced: 1.0beta7~~

~~-notes: Needs some TLC. It builds and probably works, but is far from an acceptible state.~~

~~-Allows management of users with various levels of activity.~~

~~--- a/ignorance/callbacks.c Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,701 +0,0 @@

-/*

~~- * This program is free software; you can redistribute it and/or~~

~~- * modify it under the terms of the GNU General Public License~~

~~- * as published by the Free Software Foundation; either version 2~~

~~- * of the License, or (at your option) any later version.~~

- *

~~- * This program is distributed in the hope that it will be useful,~~

~~- * but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- * GNU General Public License for more details.~~

- *

~~- * You should have received a copy of the GNU General Public License~~

~~- * along with this program; if not, write to the Free Software~~

~~- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.~~

~~- */~~

~~-#include <string.h>~~

~~-#include <gtk/gtk.h>~~

~~-#include "callbacks.h"~~

~~-#include "interface.h"~~

~~-#include "support.h"~~

~~-#include "ignorance.h"~~

~~-#include "ignorance_internal.h"~~

~~-static gboolean populate_panel(GtkTreeSelection *sel);~~

~~-static gboolean verify_form();~~

~~-static gboolean add_rule_from_form(GtkTreeView *view);~~

~~-static gboolean add_group_from_form(GtkTreeView *view);~~

~~-static gboolean edit_rule_from_form(GtkTreeView *view);~~

~~-static gboolean del_rule_from_form(GtkTreeView *view);~~

~~-static gboolean del_group_from_form(GtkTreeView *view);~~

~~-static gboolean ignorance_rule_valid(const gchar *ruletext, gint ruletype);~~

~~-static gboolean ignorance_rulename_valid(const gchar *rule_name);~~

~~-gboolean on_levelView_row_activated (GtkTreeSelection *sel, gpointer user_data) {~~

~~- populate_panel(sel);~~

~~- return FALSE;~~

~~-void on_levelAdd_clicked (GtkButton *button, gpointer user_data) {~~

~~- if(verify_form()) {~~

~~- if(!add_rule_from_form(user_data)) {~~

~~- /* XXX: */~~

~~- }~~

~~-void on_groupAdd_clicked (GtkButton *button, gpointer user_data) {~~

~~- if(verify_form()) {~~

~~- if(!add_group_from_form(user_data)) {~~

~~- /* XXX: Do something I guess? -- sadrul */~~

~~- }~~

~~-void on_levelEdit_clicked (GtkButton *button, gpointer user_data) {~~

~~- if(verify_form()) {~~

~~- if(!edit_rule_from_form(user_data)) {~~

~~- /* XXX: Do something I guess? -- sadrul */~~

~~- }~~

~~-void~~

~~-on_levelDel_clicked (GtkButton *button, gpointer user_data) {~~

~~- if(rule_selected) {~~

~~- if(verify_form()) {~~

~~- if(!del_rule_from_form(user_data)) {~~

~~- /* XXX: */~~

~~- }~~

~~- } else {~~

~~- del_group_from_form(user_data);~~

~~- }~~

~~-static gboolean populate_panel(GtkTreeSelection *sel) {~~

~~- GtkTreeIter iter;~~

~~- GtkTreeModel *model;~~

~~- gchar *levnames, *rulenames;~~

~~- ignorance_level *level=NULL;~~

~~- ignorance_rule *rule=NULL;~~

~~- GString *levgs, *rulegs;~~

~~- if (gtk_tree_selection_get_selected (sel, &model, &iter)) {~~

~~- gtk_tree_model_get (model, &iter, LEVEL_COLUMN, &levnames, -1);~~

~~- gtk_tree_model_get(model,&iter,RULE_COLUMN,&rulenames,-1);~~

~~- if(strlen(rulenames)) {~~

~~- rule_selected=TRUE;~~

~~- levgs=g_string_new(levnames);~~

~~- rulegs=g_string_new(rulenames);~~

~~- level=ignorance_get_level_name(levgs);~~

~~- rule=ignorance_level_get_rule(level,rulegs);~~

~~- if(!rule) {~~

~~- fprintf(stderr,"Ignorance: Unable to find rule %s on level %s\n",~~

~~- rulegs->str,level->name->str);~~

~~- return FALSE;~~

~~- }~~

~~- gtk_entry_set_text(GTK_ENTRY(rulename),rulenames);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(filter_cb),~~

~~- rule->score & IGNORANCE_FLAG_FILTER);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ignore_cb),~~

~~- rule->score & IGNORANCE_FLAG_IGNORE);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(message_cb),~~

~~- rule->score & IGNORANCE_FLAG_MESSAGE);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sound_cb),~~

~~- rule->score & IGNORANCE_FLAG_SOUND);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(execute_cb),~~

~~- rule->score & IGNORANCE_FLAG_EXECUTE);~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(message_cb))) {~~

~~- gtk_entry_set_text(GTK_ENTRY(message_entry),rule->message);~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sound_cb))) {~~

~~- gtk_entry_set_text(GTK_ENTRY(sound_entry),rule->sound);~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(execute_cb))) {~~

~~- gtk_entry_set_text(GTK_ENTRY(execute_entry),rule->command);~~

~~- }~~

~~- gtk_entry_set_text(GTK_ENTRY(filtervalue),~~

~~- (const gchar*)(rule->value));~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(im_type_cb),~~

~~- rule->flags & IGNORANCE_APPLY_IM);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chat_type_cb),~~

~~- rule->flags & IGNORANCE_APPLY_CHAT);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(username_type_cb),~~

~~- rule->flags & IGNORANCE_APPLY_USER);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enterleave_type_cb),~~

~~- rule->flags & IGNORANCE_APPLY_ENTERLEAVE);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(invite_type_cb),~~

~~- rule->flags & IGNORANCE_APPLY_INVITE);~~

~~-#ifdef HAVE_REGEX_H~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(regex_cb),~~

~~- rule->type & IGNORANCE_RULE_REGEX);~~

~~-#endif~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(repeat_cb),~~

~~- rule->type & IGNORANCE_RULE_REPEAT);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enabled_cb),~~

~~- rule->enabled);~~

~~- gtk_button_set_label(GTK_BUTTON(levelDel),"Remove rule");~~

~~- g_string_free(levgs,TRUE);~~

~~- g_string_free(rulegs,TRUE);~~

~~- } else {~~

~~- rule_selected=FALSE;~~

~~- gtk_entry_set_text(GTK_ENTRY(rulename),"");~~

~~- gtk_entry_set_text(GTK_ENTRY(filtervalue),"");~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(im_type_cb),FALSE);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chat_type_cb),FALSE);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(username_type_cb),~~

~~- FALSE);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enterleave_type_cb),~~

~~- FALSE);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(invite_type_cb),~~

~~- FALSE);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(filter_cb),FALSE);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ignore_cb),FALSE);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(message_cb),FALSE);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sound_cb),FALSE);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(execute_cb),FALSE);~~

~~-#ifdef HAVE_REGEX_H~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(regex_cb),FALSE);~~

~~-#endif~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(repeat_cb),FALSE);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enabled_cb),FALSE);~~

~~- gtk_button_set_label(GTK_BUTTON(levelDel),"Remove group");~~

~~- }~~

~~- g_free(levnames);~~

~~- g_free(rulenames);~~

~~- }~~

~~- return FALSE;~~

~~-void on_filter_cb_toggled (GtkButton *button, gpointer user_data) {~~

~~- gboolean amdisabled=!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));~~

~~- if(!amdisabled) {~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(message_cb),amdisabled);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ignore_cb),amdisabled);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sound_cb),amdisabled);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(execute_cb),amdisabled);~~

~~- }~~

~~- /* Maybe we *should* allow them to send a message on filter */~~

~~- gtk_widget_set_sensitive(message_cb,amdisabled);~~

~~- gtk_widget_set_sensitive(ignore_cb,amdisabled);~~

~~- gtk_widget_set_sensitive(sound_cb,amdisabled);~~

~~- gtk_widget_set_sensitive(execute_cb,amdisabled);~~

~~-void on_ignore_cb_toggled (GtkButton *button, gpointer user_data) {~~

~~- gboolean amdisabled=!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));~~

~~- if(!amdisabled) {~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(message_cb),amdisabled);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(filter_cb),amdisabled);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sound_cb),amdisabled);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(execute_cb),amdisabled);~~

~~- }~~

~~- /* Maybe we *should* allow them to send a message on ignore */~~

~~- gtk_widget_set_sensitive(message_cb,amdisabled);~~

~~- gtk_widget_set_sensitive(filter_cb,amdisabled);~~

~~- gtk_widget_set_sensitive(sound_cb,amdisabled);~~

~~- gtk_widget_set_sensitive(execute_cb,amdisabled);~~

~~-void on_message_cb_toggled (GtkButton *button, gpointer user_data) {~~

~~- gboolean isactive=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(message_cb));~~

~~- if(!isactive) {~~

~~- gtk_entry_set_text(GTK_ENTRY(message_entry),"");~~

~~- }~~

~~- gtk_widget_set_sensitive(message_entry,isactive);~~

~~-void on_sound_cb_toggled (GtkButton *button, gpointer user_data) {~~

~~- gboolean isactive=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sound_cb));~~

~~- if(!isactive) {~~

~~- gtk_entry_set_text(GTK_ENTRY(sound_entry),"");~~

~~- }~~

~~- gtk_widget_set_sensitive(sound_entry,isactive);~~

~~-#if GTK_CHECK_VERSION(2,4,0)~~

~~- gtk_widget_set_sensitive(sound_browse,isactive);~~

~~-#endif~~

~~-void on_execute_cb_toggled (GtkButton *button, gpointer user_data) {~~

~~- gboolean isactive=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(execute_cb));~~

~~- if(!isactive) {~~

~~- gtk_entry_set_text(GTK_ENTRY(execute_entry),"");~~

~~- }~~

~~- gtk_widget_set_sensitive(execute_entry,isactive);~~

~~- /*gtk_widget_set_sensitive(execute_browse,isactive);*/~~

~~-void on_sound_browse_clicked (GtkButton *button, gpointer user_data) {~~

~~-#if GTK_CHECK_VERSION(2,4,0)~~

~~- GtkWidget *fcd=gtk_file_chooser_dialog_new("Choose sound",NULL,~~

~~- GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL,~~

~~- GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,~~

~~- NULL);~~

~~- gchar *filename=NULL;~~

~~- if(GTK_RESPONSE_ACCEPT == gtk_dialog_run(GTK_DIALOG(fcd))) {~~

~~- filename=gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fcd));~~

~~- if(filename) {~~

~~- gtk_entry_set_text(GTK_ENTRY(sound_entry),filename);~~

~~- g_free(filename);~~

~~- }~~

~~- gtk_widget_destroy(fcd);~~

~~-#endif~~

~~-/*No command browser for now~~

~~-void on_execute_browse_clicked (GtkButton *button, gpointer user_data) {~~

~~- gchar *filename=gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(execute_browse));~~

~~- if(filename) {~~

~~- gtk_entry_set_text(GTK_ENTRY(execute_entry),filename);~~

~~- }~~

~~-*/~~

~~-static gboolean verify_form() {~~

~~- gboolean rv=TRUE;~~

~~- gchar *tmp;~~

~~- gint type=IGNORANCE_RULE_SIMPLETEXT;~~

~~- tmp=(gchar*)gtk_entry_get_text(GTK_ENTRY(filtervalue));~~

~~-#ifdef HAVE_REGEX_H~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(regex_cb))) {~~

~~- type=IGNORANCE_RULE_REGEX;~~

~~- }~~

~~-#endif~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(repeat_cb))) {~~

~~- type=IGNORANCE_RULE_REPEAT;~~

~~- }~~

~~- rv=ignorance_rule_valid(tmp,type);~~

~~- if(!rv) {~~

~~- purple_debug_error("ignorance","Rule invalid: %s\n",tmp);~~

~~- }else{~~

~~- tmp=(gchar*)gtk_entry_get_text(GTK_ENTRY(rulename));~~

~~- rv=ignorance_rulename_valid(tmp);~~

~~- if(!rv) {~~

~~- purple_debug_error("ignorance","Rule name invalid: %s\n",tmp);~~

~~- }~~

~~- return rv;~~

~~-static gboolean add_rule_from_form(GtkTreeView *view) {~~

~~- ignorance_rule *rule=NULL;~~

~~- ignorance_level *level=NULL;~~

~~- GString *rule_name, *level_name;~~

~~- GtkTreeSelection *sel;~~

~~- GtkTreeIter iter, childiter;~~

~~- GtkTreeModel *model;~~

~~- gchar *rule_value=NULL, *rule_message=NULL, *rule_sound=NULL,~~

~~- *rule_command=NULL;~~

~~- gint rule_score=0, rule_type=IGNORANCE_RULE_SIMPLETEXT, rule_flags=0;~~

~~- gboolean rv=FALSE, rule_enable;~~

~~- sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));~~

~~- if (!gtk_tree_selection_get_selected (sel, &model, &iter)) {~~

~~- return rv;~~

~~- }~~

~~- gtk_tree_model_get (model, &iter, LEVEL_COLUMN, &rule_value, -1);~~

~~- if(!rule_value) {~~

~~- return rv;~~

~~- }else if(!strlen(rule_value)) {~~

~~- g_free(rule_value);~~

~~- return rv;~~

~~- }~~

~~- level_name=g_string_new(rule_value);~~

~~- g_free(rule_value);~~

~~- gtk_tree_model_get(model,&iter,RULE_COLUMN,&rule_value,-1);~~

~~- if(strlen(rule_value)) {~~

~~- childiter=iter;~~

~~- gtk_tree_model_iter_parent(model,&iter,&childiter);~~

~~- }~~

~~- g_free(rule_value);~~

~~- level=ignorance_get_level_name(level_name);~~

~~- rule_name=g_string_new(gtk_entry_get_text(GTK_ENTRY(rulename)));~~

~~- rule=ignorance_level_get_rule(level,rule_name);~~

~~- if(rule) {~~

~~- g_string_free(level_name,TRUE);~~

~~- g_string_free(rule_name,TRUE);~~

~~- return rv;~~

~~- }~~

~~-#ifdef HAVE_REGEX_H~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(regex_cb))) {~~

~~- rule_type=IGNORANCE_RULE_REGEX;~~

~~- }~~

~~-#endif~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(repeat_cb))) {~~

~~- rule_type=IGNORANCE_RULE_REPEAT;~~

~~- }~~

~~- rule_value=(gchar*)gtk_entry_get_text(GTK_ENTRY(filtervalue));~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(im_type_cb))) {~~

~~- rule_flags |= IGNORANCE_APPLY_IM;~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chat_type_cb))) {~~

~~- rule_flags |= IGNORANCE_APPLY_CHAT;~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(username_type_cb))) {~~

~~- rule_flags |= IGNORANCE_APPLY_USER;~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(enterleave_type_cb))) {~~

~~- rule_flags |= IGNORANCE_APPLY_ENTERLEAVE;~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(invite_type_cb))) {~~

~~- rule_flags |= IGNORANCE_APPLY_INVITE;~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(filter_cb))) {~~

~~- rule_score |= IGNORANCE_FLAG_FILTER;~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ignore_cb))) {~~

~~- rule_score |= IGNORANCE_FLAG_IGNORE;~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(message_cb))) {~~

~~- rule_score |= IGNORANCE_FLAG_MESSAGE;~~

~~- rule_message=(gchar*)gtk_entry_get_text(GTK_ENTRY(message_entry));~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sound_cb))) {~~

~~- rule_score |= IGNORANCE_FLAG_SOUND;~~

~~- rule_sound=(gchar*)gtk_entry_get_text(GTK_ENTRY(sound_entry));~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(execute_cb))) {~~

~~- rule_score |= IGNORANCE_FLAG_EXECUTE;~~

~~- rule_command=(gchar*)gtk_entry_get_text(GTK_ENTRY(execute_entry));~~

~~- }~~

~~- rule_enable=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(enabled_cb));~~

~~- rule=ignorance_rule_newp(rule_name,rule_type,rule_value,rule_score,~~

~~- rule_flags,rule_enable,rule_message,rule_sound,~~

~~- rule_command);~~

~~- rv=ignorance_level_add_rule(level,rule);~~

~~- if(rv) {~~

~~- gtk_tree_store_append(GTK_TREE_STORE(model),&childiter,&iter);~~

~~- gtk_tree_store_set(GTK_TREE_STORE(model),&childiter,LEVEL_COLUMN,level_name->str,RULE_COLUMN,rule_name->str,-1);~~

~~- }~~

~~- g_string_free(level_name,TRUE);~~

~~- g_string_free(rule_name,TRUE);~~

~~- return rv;~~

~~-static gboolean add_group_from_form(GtkTreeView *view) {~~

~~- gboolean rv=TRUE;~~

~~- GtkTreeIter iter;~~

~~- GtkTreeStore *store = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(view)));~~

~~- ignorance_level *level=ignorance_level_new();~~

~~- level->name=g_string_new(gtk_entry_get_text(GTK_ENTRY(rulename)));~~

~~- rv=ignorance_add_level(level);~~

~~- if(rv) {~~

~~- gtk_tree_store_append(store,&iter,NULL);~~

~~- gtk_tree_store_set (store, &iter, LEVEL_COLUMN, level->name->str,~~

~~- RULE_COLUMN, "", -1);~~

~~- }~~

~~- return rv;~~

~~-static gboolean edit_rule_from_form(GtkTreeView *view) {~~

~~- ignorance_level *level;~~

~~- ignorance_rule *rule;~~

~~- GString *rule_name, *level_name;~~

~~- GtkTreeSelection *sel;~~

~~- GtkTreeIter iter;~~

~~- GtkTreeModel *model;~~

~~- gchar *rule_value, *rule_message=NULL, *rule_sound=NULL, *rule_command=NULL;~~

~~- gint rule_score=0, rule_type=IGNORANCE_RULE_SIMPLETEXT, rule_flags=0;~~

~~- gboolean rule_enable, rv;~~

~~- sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));~~

~~- if (!gtk_tree_selection_get_selected (sel, &model, &iter)) {~~

~~- return FALSE;~~

~~- }~~

~~- gtk_tree_model_get (model, &iter, LEVEL_COLUMN, &rule_value, -1);~~

~~- if(!rule_value) {~~

~~- return FALSE;~~

~~- }else if(!strlen(rule_value)) {~~

~~- g_free(rule_value);~~

~~- return FALSE;~~

~~- }~~

~~- level_name=g_string_new(rule_value);~~

~~- g_free(rule_value);~~

~~- level=ignorance_get_level_name(level_name);~~

~~- rule_name=g_string_new(gtk_entry_get_text(GTK_ENTRY(rulename)));~~

~~- rule=ignorance_level_get_rule(level,rule_name);~~

~~- if(!rule) {~~

~~- fprintf(stderr,"Ignorance: Rule \"%s\" not found on level %s\n",rule_name->str,level_name->str);~~

~~- g_string_free(rule_name,TRUE);~~

~~- g_string_free(level_name,TRUE);~~

~~- return FALSE;~~

~~- }~~

~~-#ifdef HAVE_REGEX_H~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(regex_cb))) {~~

~~- rule_type=IGNORANCE_RULE_REGEX;~~

~~- }~~

~~-#endif~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(repeat_cb))) {~~

~~- rule_type=IGNORANCE_RULE_REPEAT;~~

~~- }~~

~~- rule->type=rule_type;~~

~~- rule_value=(gchar*)gtk_entry_get_text(GTK_ENTRY(filtervalue));~~

~~- g_free(rule->value);~~

~~- rule->value=g_strdup(rule_value);~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(im_type_cb))) {~~

~~- rule_flags |= IGNORANCE_APPLY_IM;~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chat_type_cb))) {~~

~~- rule_flags |= IGNORANCE_APPLY_CHAT;~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(username_type_cb))) {~~

~~- rule_flags |= IGNORANCE_APPLY_USER;~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(enterleave_type_cb))) {~~

~~- rule_flags |= IGNORANCE_APPLY_ENTERLEAVE;~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(invite_type_cb))) {~~

~~- rule_flags |= IGNORANCE_APPLY_INVITE;~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(filter_cb))) {~~

~~- rule_score |= IGNORANCE_FLAG_FILTER;~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ignore_cb))) {~~

~~- rule_score |= IGNORANCE_FLAG_IGNORE;~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(message_cb))) {~~

~~- rule_score |= IGNORANCE_FLAG_MESSAGE;~~

~~- rule_message=(gchar*)gtk_entry_get_text(GTK_ENTRY(message_entry));~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sound_cb))) {~~

~~- rule_score |= IGNORANCE_FLAG_SOUND;~~

~~- rule_sound=(gchar*)gtk_entry_get_text(GTK_ENTRY(sound_entry));~~

~~- }~~

~~- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(execute_cb))) {~~

~~- rule_score |= IGNORANCE_FLAG_EXECUTE;~~

~~- rule_command=(gchar*)gtk_entry_get_text(GTK_ENTRY(execute_entry));~~

~~- }~~

~~- rule_enable=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(enabled_cb));~~

~~- rule=ignorance_rule_newp(rule_name, rule_type, rule_value, rule_score,~~

~~- rule_flags,rule_enable,rule_message,rule_sound,~~

~~- rule_command);~~

~~- rv=ignorance_level_remove_rule(level,rule_name);~~

~~- if(rv) {~~

~~- rv=ignorance_level_add_rule(level,rule);~~

~~- }~~

~~- rule->flags=rule_flags;~~

~~- rule->enabled=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(enabled_cb));~~

~~- g_string_free(rule_name,TRUE);~~

~~- g_string_free(level_name,TRUE);~~

~~- return rv;~~

~~-static gboolean del_rule_from_form(GtkTreeView *view) {~~

~~- ignorance_level *level;~~

~~- ignorance_rule *rule;~~

~~- GString *rule_name, *level_name;~~

~~- GtkTreeSelection *sel;~~

~~- GtkTreeIter iter;~~

~~- GtkTreeModel *model;~~

~~- gchar *rule_value;~~

~~- gboolean rv=FALSE;~~

~~- sel=gtk_tree_view_get_selection(GTK_TREE_VIEW(view));~~

~~- if (!gtk_tree_selection_get_selected (sel, &model, &iter)) {~~

~~- return rv;~~

~~- }~~

~~- gtk_tree_model_get (model, &iter, LEVEL_COLUMN, &rule_value, -1);~~

~~- if(!rule_value) {~~

~~- return rv;~~

~~- }else if(!strlen(rule_value)) {~~

~~- g_free(rule_value);~~

~~- return rv;~~

~~- }~~

~~- level_name=g_string_new(rule_value);~~

~~- g_free(rule_value);~~

~~- level=ignorance_get_level_name(level_name);~~

~~- rule_name=g_string_new(gtk_entry_get_text(GTK_ENTRY(rulename)));~~

~~- rule=ignorance_level_get_rule(level,rule_name);~~

~~- if(!rule) {~~

~~- fprintf(stderr,"Ignorance: Rule \"%s\" not found on level %s\n",~~

~~- rule_name->str,level_name->str);~~

~~- g_string_free(rule_name,TRUE);~~

~~- g_string_free(level_name,TRUE);~~

~~- return rv;~~

~~- }~~

~~- rv=ignorance_level_remove_rule(level,rule_name);~~

~~- if(rv) {~~

~~- gtk_tree_store_remove(GTK_TREE_STORE(model),&iter);~~

~~- }~~

~~- g_string_free(rule_name,TRUE);~~

~~- g_string_free(level_name,TRUE);~~

~~- return rv;~~

~~-static gboolean del_group_from_form(GtkTreeView *view) {~~

~~- GString *level_name;~~

~~- GtkTreeSelection *sel;~~

~~- GtkTreeIter iter;~~

~~- GtkTreeModel *model;~~

~~- gchar *rule_value;~~

~~- gboolean rv=FALSE;~~

~~- sel=gtk_tree_view_get_selection(GTK_TREE_VIEW(view));~~

~~- if (!gtk_tree_selection_get_selected (sel, &model, &iter)) {~~

~~- return rv;~~

~~- }~~

~~- gtk_tree_model_get (model, &iter, LEVEL_COLUMN, &rule_value, -1);~~

~~- if(!rule_value) {~~

~~- return rv;~~

~~- }else if(!strlen(rule_value)) {~~

~~- g_free(rule_value);~~

~~- return rv;~~

~~- }~~

~~- level_name=g_string_new(rule_value);~~

~~- g_free(rule_value);~~

~~- ignorance_remove_level(level_name);~~

~~- gtk_tree_store_remove(GTK_TREE_STORE(model),&iter);~~

~~- rv=TRUE;~~

~~- return rv;~~

~~-gboolean load_form_with_levels(GtkTreeView *tree, GPtrArray *levels) {~~

~~- int i,j;~~

~~- GtkTreeStore *store=GTK_TREE_STORE(gtk_tree_view_get_model(tree));~~

~~- GtkTreeIter iter, ruleiter;~~

~~- ignorance_level *level;~~

~~- ignorance_rule *rule;~~

~~- if(!levels) {~~

~~- return FALSE;~~

~~- }~~

~~- for(i=0;i<levels->len;++i) {~~

~~- level=(ignorance_level*)g_ptr_array_index(levels,i);~~

~~- gtk_tree_store_append(store,&iter,NULL);~~

~~- gtk_tree_store_set (store, &iter, LEVEL_COLUMN, level->name->str,~~

~~- RULE_COLUMN, "", -1);~~

~~- for(j=0;j<level->rules->len;++j) {~~

~~- rule=(ignorance_rule*)g_ptr_array_index(level->rules,j);~~

~~- gtk_tree_store_append(store,&ruleiter,&iter);~~

~~- gtk_tree_store_set(store,&ruleiter, LEVEL_COLUMN, level->name->str,~~

~~- RULE_COLUMN, rule->name->str, -1);~~

~~- }~~

~~- return FALSE;~~

~~-static gboolean ignorance_rule_valid(const gchar *ruletext, gint ruletype) {~~

~~- gboolean rv=FALSE;~~

~~-#ifdef HAVE_REGEX_H~~

~~- regex_t reg;~~

~~-#endif~~

~~- switch(ruletype) {~~

~~- case IGNORANCE_RULE_SIMPLETEXT:~~

~~- case IGNORANCE_RULE_REPEAT:~~

~~- rv=TRUE;~~

~~- break;~~

~~-#ifdef HAVE_REGEX_H~~

~~- case IGNORANCE_RULE_REGEX:~~

~~- rv=!((gboolean)regcomp(&reg,ruletext,REG_EXTENDED | REG_NOSUB));~~

~~- rv=(rv && strlen(ruletext));~~

~~- regfree(&reg);~~

~~- break;~~

~~-#endif~~

~~- }~~

~~- return rv;~~

~~-static gboolean ignorance_rulename_valid(const gchar *rule_name) {~~

~~- return TRUE;~~

~~--- a/ignorance/callbacks.h Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,60 +0,0 @@

-/*

~~- * This program is free software; you can redistribute it and/or~~

~~- * modify it under the terms of the GNU General Public License~~

~~- * as published by the Free Software Foundation; either version 2~~

~~- * of the License, or (at your option) any later version.~~

- *

~~- * This program is distributed in the hope that it will be useful,~~

~~- * but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- * GNU General Public License for more details.~~

- *

~~- * You should have received a copy of the GNU General Public License~~

~~- * along with this program; if not, write to the Free Software~~

~~- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.~~

~~- */~~

~~-#ifndef IGNORANCE_CALLBACKS_H~~

~~-#define IGNORANCE_CALLBACKS_H~~

~~-#include <gtk/gtk.h>~~

~~-#ifdef HAVE_REGEX_H~~

~~-# include <regex.h>~~

~~-#endif~~

~~-enum{~~

~~- LEVEL_COLUMN,~~

~~- RULE_COLUMN,~~

~~- NUM_COLUMNS~~

~~-};~~

~~-gboolean on_levelView_row_activated (GtkTreeSelection *sel, gpointer user_data);~~

~~-void on_levelAdd_clicked (GtkButton *button, gpointer user_data);~~

~~-void on_groupAdd_clicked (GtkButton *button, gpointer user_data);~~

~~-void on_levelEdit_clicked (GtkButton *button, gpointer user_data);~~

~~-void on_levelDel_clicked (GtkButton *button, gpointer user_data);~~

~~-void on_sound_browse_clicked (GtkButton *button, gpointer user_data);~~

-/*

~~-void on_execute_browse_clicked (GtkButton *button, gpointer user_data);~~

~~-*/~~

~~-void on_filter_cb_toggled (GtkButton *button, gpointer user_data);~~

~~-void on_ignore_cb_toggled (GtkButton *button, gpointer user_data);~~

~~-void on_message_cb_toggled (GtkButton *button, gpointer user_data);~~

~~-void on_sound_cb_toggled (GtkButton *button, gpointer user_data);~~

~~-void on_execute_cb_toggled (GtkButton *button, gpointer user_data);~~

~~-gboolean load_form_with_levels (GtkTreeView *tree, GPtrArray *levels);~~

~~-#endif~~

~~--- a/ignorance/ignorance.c Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,1209 +0,0 @@

-/*

~~- * Ignorance - Make up for deficiencies in Purple's privacy~~

- *

~~- * Copyright (c) 200?-2006 Levi Bard~~

- *

~~- * This program is free software; you can redistribute it and/or~~

~~- * modify it under the terms of the GNU General Public License~~

~~- * as published by the Free Software Foundation; either version 2~~

~~- * of the License, or (at your option) any later version.~~

- *

~~- * This program is distributed in the hope that it will be useful,~~

~~- * but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- * GNU General Public License for more details.~~

- *

~~- * You should have received a copy of the GNU General Public License~~

~~- * along with this program; if not, write to the Free Software~~

~~- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.~~

~~- */~~

~~-#define PURPLE_PLUGINS~~

~~-/* ignorance headers */~~

~~-#include "ignorance_level.h"~~

~~-#include "ignorance_internal.h"~~

~~-#include "ignorance.h"~~

~~-#include "ignorance_denizen.h"~~

~~-#include "ignorance_violation.h"~~

~~-#include "ignorance_rule.h"~~

~~-/* GTK Purple headers */~~

~~-#include <gtkplugin.h>~~

~~-#include <gtkutils.h>~~

~~-#include "interface.h"~~

~~-/* libpurple headers */~~

~~-#include <blist.h>~~

~~-#include <cmds.h>~~

~~-#include <conversation.h>~~

~~-#include <purple.h>~~

~~-#include <plugin.h>~~

~~-#include <privacy.h>~~

~~-#include <signals.h>~~

~~-#include <sound.h>~~

~~-#include <util.h>~~

~~-#include <version.h>~~

~~-/* libc headers */~~

~~-#include <errno.h>~~

~~-#include <signal.h>~~

~~-#include <stdio.h>~~

~~-#include <string.h>~~

~~-#include <stdlib.h>~~

~~-#include <time.h>~~

~~-#include <unistd.h>~~

~~-/* for OSes that can at least *pretend* to be decent... */~~

~~-#ifndef _WIN32~~

~~-# include <sys/wait.h>~~

~~-# include <sys/types.h>~~

~~-# include <sys/select.h>~~

~~-# include <fcntl.h>~~

~~-# include <sys/stat.h>~~

~~-#endif~~

~~-/* globals */~~

~~-static GPtrArray *levels;~~

~~-static ignorance_level* ignorance_get_default_level() {~~

~~- gint i = 0;~~

~~- ignorance_level *il;~~

~~- for(i = 0; i < levels->len; ++i) {~~

~~- il = (ignorance_level*)g_ptr_array_index(levels, i);~~

~~- if(!strcmp(il->name->str, "Default"))~~

~~- return il;~~

~~- }~~

~~- return NULL;~~

~~-static gboolean ignorance_user_match(ignorance_level *il, const GString *username){~~

~~- return (ignorance_level_has_denizen(il,username));~~

~~-static ignorance_level* ignorance_get_user_level(const GString *username){~~

~~- gint i = 0;~~

~~- ignorance_level *il = NULL;~~

~~- for(i = 0; i < levels->len; ++i){~~

~~- il = (ignorance_level*)g_ptr_array_index(levels, i);~~

~~- if(ignorance_user_match(il, username))~~

~~- return il;~~

~~- }~~

~~- return ignorance_get_default_level();~~

~~-static void purple_buddy_add(gpointer key, gpointer value, gpointer user_data) {~~

~~- PurpleBuddy *buddy = (PurpleBuddy*)value;~~

~~- ignorance_level *level = (ignorance_level*)user_data;~~

~~- PurpleAccount *account = NULL;~~

~~- gchar *name = NULL;~~

~~- GString *tmp;~~

~~- if(buddy && level) {~~

~~- name = (gchar*)buddy->name;~~

~~- account = buddy->account;~~

~~- tmp = g_string_new(purple_account_get_protocol_id(account));~~

~~- g_string_append(tmp, purple_normalize_nocase(account, name));~~

~~- if(ignorance_get_user_level(tmp) == ignorance_get_default_level()) {~~

~~- ignorance_level_add_denizen(level, tmp);~~

~~- if(strstr(level->name->str, "WL")) {~~

~~- purple_privacy_deny_remove(account, name, FALSE);~~

~~- purple_privacy_permit_add(account, name, FALSE);~~

~~- } else if(strstr(level->name->str,"BL")) {~~

~~- purple_privacy_permit_remove(account, name, FALSE);~~

~~- purple_privacy_deny_add(account, name, FALSE);~~

~~- }~~

~~- g_string_free(tmp, TRUE);~~

~~- } else {~~

~~- purple_debug_error("ignorance", "Bad arguments to purple_buddy_add\n");~~

~~- }~~

~~-static gint buf_get_line(gchar *ibuf, gchar **buf, gint *position, gint len) {~~

~~- gint pos = *position,~~

~~- spos = pos;~~

~~- if (pos == len)~~

~~- return 0;~~

~~- while (ibuf[pos++] != '\n') {~~

~~- if (pos == len)~~

~~- return 0;~~

~~- }~~

~~- pos--;~~

~~- ibuf[pos] = 0;~~

~~- *buf = &ibuf[spos];~~

~~- pos++;~~

~~- *position = pos;~~

~~- return 1;~~

~~-static gboolean import_curphoo_list() {~~

~~- gchar *buf, *ibuf;~~

~~- gint pnt = 0,~~

~~- rule_flags = IGNORANCE_APPLY_CHAT | IGNORANCE_APPLY_IM | IGNORANCE_APPLY_ENTERLEAVE;~~

~~- gsize size = 0;~~

~~- FILE *curphoofile;~~

~~- ignorance_level *curphoolevel = NULL;~~

~~- ignorance_rule *curphoorule = NULL;~~

~~- GString *tmp = NULL;~~

~~- buf = g_build_filename(g_get_home_dir(), ".curphoo", "ignore", NULL);~~

~~- if(!(curphoofile = fopen(buf, "r"))) {~~

~~- purple_debug_error("ignorance", "Unable to open %s\n", buf);~~

~~- g_free(buf);~~

~~- return FALSE;~~

~~- } else~~

~~- fclose(curphoofile);~~

~~- g_file_get_contents(buf, &ibuf, &size, NULL);~~

~~- tmp = g_string_new("CurphooBL");~~

~~- curphoolevel = ignorance_get_level_name(tmp);~~

~~- if(!curphoolevel) {~~

~~- purple_debug_info("ignorance", "Creating new Curphoo blacklist\n");~~

~~-#ifdef HAVE_REGEX_H~~

~~- curphoorule = ignorance_rule_newp(g_string_new("Everything"),~~

~~- IGNORANCE_RULE_REGEX,(gchar*)".*", IGNORANCE_FLAG_FILTER,~~

~~- rule_flags, TRUE, NULL, NULL, NULL);~~

~~-#else~~

~~- curphoorule=ignorance_rule_newp(g_string_new("Everything"),~~

~~- IGNORANCE_RULE_SIMPLETEXT, (gchar*)"", IGNORANCE_FLAG_FILTER,~~

~~- rule_flags, TRUE, NULL, NULL, NULL);~~

~~-#endif~~

~~- curphoolevel = ignorance_level_new();~~

~~- curphoolevel->name = g_string_new(tmp->str);~~

~~- ignorance_level_add_rule(curphoolevel, curphoorule);~~

~~- ignorance_add_level(curphoolevel);~~

~~- }~~

~~- if(!tmp)~~

~~- tmp = g_string_new("");~~

~~- g_free(buf);~~

~~- purple_debug_info("ignorance", "Preparing to read in curphoo blacklist users\n");~~

~~- for(; buf_get_line(ibuf, &buf, &pnt, size); ){~~

~~- g_string_assign(tmp, "prpl-yahoo");~~

~~- g_string_append(tmp, purple_normalize_nocase(NULL,buf));~~

~~- if(ignorance_get_user_level(tmp) == ignorance_get_default_level())~~

~~- ignorance_level_add_denizen(curphoolevel, tmp);~~

~~- }~~

~~- g_free(ibuf);~~

~~- pnt = 0;~~

~~- buf = g_build_filename(g_get_home_dir(), ".curphoo", "buddies", NULL);~~

~~- g_file_get_contents(buf, &ibuf, &size, NULL);~~

~~- g_string_assign(tmp, "CurphooWL");~~

~~- curphoolevel = ignorance_get_level_name(tmp);~~

~~- if(!curphoolevel) {~~

~~- purple_debug_info("ignorance", "Creating new Curphoo whitelist\n");~~

~~- curphoolevel = ignorance_level_new();~~

~~- curphoolevel->name = g_string_new(tmp->str);~~

~~- ignorance_add_level(curphoolevel);~~

~~- }~~

~~- g_free(buf);~~

~~- purple_debug_info("ignorance", "Preparing to read in curphoo whitelist users\n");~~

~~- for(; buf_get_line(ibuf, &buf, &pnt, size); ) {~~

~~- g_string_assign(tmp, "prpl-yahoo");~~

~~- g_string_append(tmp, purple_normalize_nocase(NULL, buf));~~

~~- if(ignorance_get_user_level(tmp) == ignorance_get_default_level())~~

~~- ignorance_level_add_denizen(curphoolevel, tmp);~~

~~- }~~

~~- g_free(ibuf);~~

~~- purple_debug_info("ignorance", "Done importing Curphoo users\n");~~

~~- return TRUE;~~

~~-static gboolean import_purple_list() {~~

~~- PurpleBuddyList *bl;~~

~~- GString *wlname;~~

~~- ignorance_level *wl;~~

~~- gboolean rv = FALSE;~~

~~- bl = purple_get_blist();~~

~~- wlname = g_string_new("WL");~~

~~- wl = ignorance_get_level_name(wlname);~~

~~- if(bl && wl) {~~

~~- g_hash_table_foreach(bl->buddies, purple_buddy_add, wl);~~

~~- rv = TRUE;~~

~~- } else~~

~~- purple_debug_error("ignorance", "Unable to get Purple buddy list!\n");~~

~~- g_string_free(wlname, TRUE);~~

~~- return rv;~~

~~-static gboolean import_zinc_list()~~

~~- FILE *zincfile;~~

~~- gchar *buf, *ibuf;~~

~~- gint pnt = 0,~~

~~- rule_flags = IGNORANCE_APPLY_CHAT | IGNORANCE_APPLY_IM | IGNORANCE_APPLY_ENTERLEAVE;~~

~~- gsize size = 0;~~

~~- ignorance_level *zinclevel = NULL;~~

~~- ignorance_rule *zincrule = NULL;~~

~~- GString *tmp = NULL;~~

~~- buf = g_build_filename(g_get_home_dir(), ".zinc", "ignore", NULL);~~

~~- if(!(zincfile = fopen(buf, "r"))) {~~

~~- purple_debug_error("ignorance", "Unable to open %s\n",buf);~~

~~- g_free(buf);~~

~~- return FALSE;~~

~~- } else~~

~~- fclose(zincfile);~~

~~- g_file_get_contents(buf, &ibuf, &size, NULL);~~

~~- tmp = g_string_new("ZincBL");~~

~~- zinclevel = ignorance_get_level_name(tmp);~~

~~- if(!zinclevel){~~

~~- purple_debug_info("ignorance", "Creating new Zinc blacklist\n");~~

~~-#ifdef HAVE_REGEX_H~~

~~- zincrule = ignorance_rule_newp(g_string_new("Everything"),~~

~~- IGNORANCE_RULE_REGEX, (gchar*)".*", IGNORANCE_FLAG_FILTER,~~

~~- rule_flags, TRUE, NULL, NULL, NULL);~~

~~-#else~~

~~- zincrule = ignorance_rule_newp(g_string_new("Everything"),~~

~~- IGNORANCE_RULE_SIMPLETEXT, (gchar*)"", IGNORANCE_FLAG_FILTER,~~

~~- rule_flags, TRUE, NULL, NULL, NULL);~~

~~-#endif~~

~~- zinclevel = ignorance_level_new();~~

~~- zinclevel->name = g_string_new(tmp->str);~~

~~- ignorance_level_add_rule(zinclevel, zincrule);~~

~~- ignorance_add_level(zinclevel);~~

~~- }~~

~~- if(!tmp)~~

~~- tmp=g_string_new("");~~

~~- g_free(buf);~~

~~- purple_debug_info("ignorance", "Preparing to read in zinc blacklist users\n");~~

~~- for(; buf_get_line(ibuf, &buf, &pnt, size); ) {~~

~~- g_string_assign(tmp, "prpl-yahoo");~~

~~- g_string_append(tmp, purple_normalize_nocase(NULL, buf));~~

~~- if(ignorance_get_user_level(tmp) == ignorance_get_default_level())~~

~~- ignorance_level_add_denizen(zinclevel, tmp);~~

~~- }~~

~~- g_free(ibuf);~~

~~- pnt = 0;~~

~~- buf = g_build_filename(g_get_home_dir(), ".zinc", "whitelist", NULL);~~

~~- g_file_get_contents(buf, &ibuf, &size, NULL);~~

~~- g_string_assign(tmp, "ZincWL");~~

~~- zinclevel = ignorance_get_level_name(tmp);~~

~~- if(!zinclevel) {~~

~~- purple_debug_info("ignorance", "Creating new Zinc whitelist\n");~~

~~- zinclevel = ignorance_level_new();~~

~~- zinclevel->name = g_string_new(tmp->str);~~

~~- ignorance_add_level(zinclevel);~~

~~- }~~

~~- g_free(buf);~~

~~- purple_debug_info("ignorance", "Preparing to read in zinc whitelist users\n");~~

~~- for(; buf_get_line(ibuf, &buf, &pnt, size); ) {~~

~~- /* maybe this will be this way eventually, when i kill unnecessary~~

~~- * GStrings - rekkanoryo */~~

~~- /* tmp = g_strdup_printf("prpl-yahoo %s", purple_normalize_nocase(NULL, buf)); */~~

~~- g_string_assign(tmp, "prpl-yahoo");~~

~~- g_string_append(tmp, purple_normalize_nocase(NULL, buf));~~

~~- if(ignorance_get_user_level(tmp) == ignorance_get_default_level())~~

~~- ignorance_level_add_denizen(zinclevel, tmp);~~

~~- }~~

~~- g_free(ibuf);~~

~~- purple_debug_info("ignorance", "Done importing Zinc users\n");~~

~~- return TRUE;~~

~~-static gboolean ignorance_rm_user(PurpleConversation *conv, const gchar *username) {~~

~~- gchar *msgbuf = NULL, *cursor = NULL;~~

~~- gboolean retval = FALSE;~~

~~- GString *usergs;~~

~~- ignorance_level *level = NULL;~~

~~- int len=0;~~

~~- usergs = g_string_new(purple_normalize_nocase(NULL, username));~~

~~- level=ignorance_get_user_level(usergs);~~

~~- if(level) {~~

~~- retval = ignorance_level_remove_denizen(level, usergs);~~

~~- purple_debug_info("ignorance", "Done removing denizen from level\n");~~

~~- if(conv) {~~

~~- purple_debug_info("ignorance",~~

~~- "Creating status message for username %x and level %x\n",~~

~~- username, level);~~

~~- if(retval) {~~

~~- msgbuf = g_strdup_printf(_("Successfully removed %s from %s"),~~

~~- username, level->name->str);~~

~~- retval = TRUE;~~

~~- } else~~

~~- msgbuf = g_strdup_printf(_("Unable to remove %s from %s\n"),~~

~~- username, level->name->str);~~

~~- purple_debug_info("ignorance", "Writing status message\n");~~

~~- purple_conversation_write(conv, NULL, msgbuf, PURPLE_MESSAGE_NO_LOG,~~

~~- time(NULL));~~

~~- g_free(msgbuf);~~

~~- }~~

~~- if(conv) {~~

~~- purple_debug_info("ignorance",~~

~~- "Preparing to push through to purple privacy\n");~~

~~- len = strlen(purple_account_get_protocol_id(~~

~~- purple_conversation_get_account(conv)));~~

~~- cursor = (gchar*)username + len;~~

~~- if(cursor && (strlen(username) > len)) {~~

~~- purple_debug_info("ignorance", "Removing from permit list\n");~~

~~- purple_privacy_permit_remove(purple_conversation_get_account(conv),~~

~~- cursor, FALSE);~~

~~- purple_debug_info("ignorance", "Removing from deny list\n");~~

~~- purple_privacy_deny_remove(purple_conversation_get_account(conv), cursor,~~

~~- FALSE);~~

~~- if(purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) {~~

~~- purple_debug_info("ignorance", "Removing from chat ignore list\n");~~

~~- purple_conv_chat_unignore(PURPLE_CONV_CHAT(conv), cursor);~~

~~- }~~

~~- g_string_free(usergs, TRUE);~~

~~- purple_debug_info("ignorance", "Exiting\n");~~

~~- return retval;~~

~~-static gboolean~~

~~-ignorance_place_user_name(const GString *level_name, const GString *username) {~~

~~- ignorance_level *current_level = ignorance_get_user_level(username),~~

~~- *newlevel = ignorance_get_level_name(level_name);~~

~~- if(newlevel) {~~

~~- if(newlevel != current_level) {~~

~~- ignorance_level_remove_denizen(current_level, username);~~

~~- ignorance_level_add_denizen(newlevel, username);~~

~~- return TRUE;~~

~~- }~~

~~- } else~~

~~- purple_debug_error("ignorance", "Invalid level %s\n", level_name->str);~~

~~- return FALSE;~~

~~-static gboolean ignorance_bl_user(PurpleConversation *conv, const gchar *username,~~

~~- const gchar *actual_levelname)~~

~~- gboolean retval = FALSE;~~

~~- gchar *msgbuf = NULL;~~

~~- GString *wlname, *usergs;~~

~~- PurpleAccount *account = NULL;~~

~~- wlname = g_string_new(actual_levelname);~~

~~- g_return_val_if_fail(conv != NULL, retval);~~

~~- account = purple_conversation_get_account(conv);~~

~~- usergs = g_string_new(purple_account_get_protocol_id(account));~~

~~- g_string_append(usergs, purple_normalize_nocase(NULL, username));~~

~~- if(ignorance_place_user_name(wlname, usergs)){~~

~~- retval = TRUE;~~

~~- purple_privacy_permit_remove(account, username, FALSE);~~

~~- purple_privacy_deny_add(account, username, FALSE);~~

~~- if(purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT)~~

~~- purple_conv_chat_ignore(PURPLE_CONV_CHAT(conv), username);~~

~~- msgbuf = g_strdup_printf(_("Assigned user %s to %s"), username,~~

~~- actual_levelname);~~

~~- } else~~

~~- msgbuf = g_strdup_printf(~~

~~- _("Unable to assign user %s to %s - may already be there"),~~

~~- username, actual_levelname);~~

~~- purple_conversation_write(conv, NULL, msgbuf, PURPLE_MESSAGE_NO_LOG, time(NULL));~~

~~- g_free(msgbuf);~~

~~- g_string_free(usergs, TRUE);~~

~~- g_string_free(wlname, TRUE);~~

~~- return retval;~~

~~-#ifndef _WIN32~~

~~-static int read_nonblock(int fd,unsigned long len,unsigned long timeout,GString *inp){~~

~~- int chrs=0, timedout=FALSE, rv=0;~~

~~- unsigned long timeout_usec=timeout*1000000, tlapsed=0;~~

~~- static const int SLEEP_INTERVAL=50000;~~

~~- gchar *ptr=g_malloc((len+1)*sizeof(gchar));~~

~~- while (chrs < len){~~

~~- if (tlapsed > timeout_usec){~~

~~- timedout = TRUE;~~

~~- break;~~

~~- }~~

~~- if ((rv = read (fd, ptr, (len - chrs))) < 0){~~

~~- rv = errno;~~

~~- usleep (SLEEP_INTERVAL);~~

~~- tlapsed += SLEEP_INTERVAL;~~

~~- continue;~~

~~- } else if (rv == 0)~~

~~- break;~~

~~- chrs += rv;~~

~~- *(ptr + rv)= 0;~~

~~- g_string_append(inp,ptr);~~

~~- *ptr=0;~~

~~- }~~

~~- g_free(ptr);~~

~~- if(timedout)~~

~~- return -1;~~

~~- else~~

~~- return chrs;~~

~~-#endif~~

-static gchar *

~~-yahoo_strip_tattoo(gchar *origmessage) {~~

~~- gchar *cursor = NULL, *cursor2 = NULL, *beginstack = NULL,~~

~~- *endstack = NULL, *message = NULL;~~

~~- gint rvindex;~~

~~- message = g_ascii_strdown(origmessage, -1);~~

~~- cursor = strstr(message, "<font");~~

~~- if(message == cursor) {~~

~~- cursor2 = strstr(message, "tattoo");~~

~~- if(cursor2) {~~

~~- cursor = strstr(cursor2, ">");~~

~~- for( ; cursor; ) {~~

~~- endstack = strstr(cursor, "</");~~

~~- beginstack = strstr(cursor, "<");~~

~~- if(endstack == NULL || beginstack== NULL) {~~

~~- cursor = NULL;~~

~~- break;~~

~~- }~~

~~- cursor = strstr(endstack, ">");~~

~~- if(beginstack == endstack)~~

~~- break;~~

~~- }~~

~~- if(cursor) {~~

~~- rvindex = cursor + 1 - message;~~

~~- purple_debug_info("yahoo", "%s\nconverted to \n%s\n%s\n\n",~~

~~- origmessage, cursor + 1, origmessage + rvindex);~~

~~- g_free(message);~~

~~- return origmessage + rvindex;~~

~~- }~~

~~- g_free(message);~~

~~- return origmessage;~~

~~-static int~~

~~-handle_exec_command (const gchar *command, GString *result,unsigned long maxlen) {~~

~~-#ifndef _WIN32~~

~~- GString *inp=g_string_new("");~~

~~- int p[2], pid, chrs;~~

~~- pipe(p);~~

~~- chrs = inp->len;~~

~~- if ((pid = fork ()) == -1) {~~

~~- g_string_assign (result, command);~~

~~- g_string_append (result, ": couldn't fork");~~

~~- return -1;~~

~~- } else if (pid){~~

~~- int rv;~~

~~- int flags = fcntl (p[0], F_GETFL, 0);~~

~~- close (p[1]);~~

~~- fcntl (p[0], F_SETFL, flags | O_NONBLOCK);~~

~~- rv=read_nonblock(p[0],maxlen-chrs,EXEC_TIMEOUT,inp);~~

~~- if (kill (pid, 0) == 0)~~

~~- kill (pid, SIGKILL);~~

~~- if (rv < 0)~~

~~- g_string_append (inp, "[process timed out]");~~

~~- else if(maxlen==(rv+chrs))~~

~~- g_string_append(inp,"...");~~

~~- else if(('\n'==(inp->str)[inp->len-1]))~~

~~- g_string_truncate(inp,inp->len-1);~~

~~- g_string_assign (result, inp->str);~~

~~- g_string_free(inp,TRUE);~~

~~- waitpid (pid, NULL, 0);~~

~~- } else {~~

~~- close (p[0]);~~

~~- if (p[1] != STDOUT_FILENO){~~

~~- dup2 (p[1], STDOUT_FILENO);~~

~~- close (p[1]);~~

~~- }~~

~~- if (STDERR_FILENO != STDOUT_FILENO)~~

~~- dup2 (STDOUT_FILENO, STDERR_FILENO);~~

~~- execlp ("sh", "sh", "-c", command, NULL);~~

~~- }~~

~~- return 0;~~

~~-#else~~

~~- gint retval;~~

~~- gchar *message = NULL;~~

~~- g_string_assign (result, command);~~

~~- g_string_append (result, ": ");~~

~~- if (G_WIN32_HAVE_WIDECHAR_API ()) {~~

~~- wchar_t *wc_cmd = g_utf8_to_utf16(command,~~

~~- -1, NULL, NULL, NULL);~~

~~- retval = (gint)ShellExecuteW(NULL,NULL,wc_cmd,NULL,NULL,SW_SHOWNORMAL);~~

~~- g_free(wc_cmd);~~

~~- } else {~~

~~- char *l_cmd = g_locale_from_utf8(command,~~

~~- -1, NULL, NULL, NULL);~~

~~- retval = (gint)ShellExecuteA(NULL,NULL,l_cmd,NULL,NULL,SW_SHOWNORMAL);~~

~~- g_free(l_cmd);~~

~~- }~~

~~- if (retval<=32) {~~

~~- message = g_win32_error_message(retval);~~

~~- g_string_append(result,message);~~

~~- }~~

~~- purple_debug_info("Ignorance", "Execute command called for: "~~

~~- "%s\n%s%s%s", command, retval ? "" : "Error: ",~~

~~- retval ? "" : message, retval ? "" : "\n");~~

~~- g_free(message);~~

~~- return 0;~~

~~-#endif~~

~~-static gboolean~~

~~-apply_rule(PurpleConversation *conv, PurpleAccount *account,~~

~~- const GString *username, const GString *text, gint flags)~~

~~- gint text_score = 0;~~

~~- gboolean rv = TRUE, newconv = FALSE;~~

~~- GList *violations = NULL, *cursor = NULL;~~

~~- GString *tmp;~~

~~- GString *prpluser = g_string_new(purple_account_get_protocol_id(account));~~

~~- ignorance_level *user_level;~~

~~- ignorance_violation *viol;~~

~~- PurpleConversationType conv_type;~~

~~- g_string_append(prpluser, purple_normalize_nocase(account, username->str));~~

~~- user_level=ignorance_get_user_level(prpluser);~~

~~- purple_debug_info("ignorance", "Preparing to check %s\n", text->str);~~

~~- text_score=ignorance_level_rulecheck(user_level, prpluser, text, flags,~~

~~- &violations);~~

~~- purple_debug_info("ignorance", "Got score %d\n", text_score);~~

~~- if(!(text_score & (IGNORANCE_FLAG_FILTER | IGNORANCE_FLAG_IGNORE))) {~~

~~- rv = FALSE;~~

~~- if(text_score) {~~

~~- for(cursor = violations; cursor; cursor = cursor->next) {~~

~~- viol = (ignorance_violation*)(cursor->data);~~

~~- purple_debug_info("ignorance", "Got violation type %d: %s\n",~~

~~- viol->type,viol->value);~~

~~- switch(viol->type) {~~

~~- case IGNORANCE_FLAG_SOUND:~~

~~- purple_debug_info("ignorance",~~

~~- "Attempting to play sound %s\n", viol->value);~~

~~- purple_sound_play_file(viol->value, account);~~

~~- break;~~

~~- case IGNORANCE_FLAG_EXECUTE:~~

~~- purple_debug_info("ignorance",~~

~~- "Attempting to execute command %s\n",~~

~~- viol->value);~~

~~- tmp = g_string_new("");~~

~~- handle_exec_command(viol->value, tmp, 512);~~

~~- if(conv)~~

~~- purple_conversation_write(conv,~~

~~- purple_account_get_username(account),~~

~~- tmp->str, PURPLE_MESSAGE_NO_LOG, time(NULL));~~

~~- g_string_free(tmp, TRUE);~~

~~- break;~~

~~- case IGNORANCE_FLAG_MESSAGE:~~

~~- if(!conv) {~~

~~- newconv = TRUE;~~

~~- conv = purple_conversation_new(PURPLE_CONV_TYPE_IM,~~

~~- account, username->str);~~

~~- }~~

~~- conv_type = purple_conversation_get_type(conv);~~

~~- if(conv_type == PURPLE_CONV_TYPE_IM) {~~

~~- purple_conv_im_send(PURPLE_CONV_IM(conv), viol->value);~~

~~- } else if(conv_type == PURPLE_CONV_TYPE_CHAT) {~~

~~- purple_conv_chat_send(PURPLE_CONV_CHAT(conv),~~

~~- viol->value);~~

~~- } /* braces for readability only */~~

~~- if(newconv)~~

~~- purple_conversation_destroy(conv);~~

~~- break;~~

~~- default:~~

~~- break;~~

~~- }~~

~~- } else if(text_score & IGNORANCE_FLAG_IGNORE)~~

~~- ignorance_bl_user(conv, username->str, "BL");~~

~~- g_string_free(prpluser, TRUE);~~

~~- purple_debug_info("ignorance", "Preparing to free violation items\n");~~

~~- g_list_foreach(violations, ignorance_violation_free_g, NULL);~~

~~- purple_debug_info("ignorance",~~

~~- "Done freeing violation items, now freeing list itself\n");~~

~~- g_list_free(violations);~~

~~- purple_debug_info("ignorance",~~

~~- "Done checking, returning from applying rules\n");~~

~~- return rv;~~

~~-static gboolean substitute (PurpleConversation *conv,PurpleAccount *account,~~

~~- const gchar *sender, gchar **message, gint msgflags) {~~

~~- GString *username=NULL, *text=NULL;~~

~~- gboolean rv=FALSE;~~

~~- gchar *newmsg, *cursor;~~

~~- if (NULL == message)~~

~~- return FALSE;~~

~~- else if (NULL == (*message))~~

~~- return FALSE;~~

~~- username=g_string_new(purple_normalize_nocase(account,sender));~~

~~- purple_debug_info("ignorance","Got message \"%s\" from user \"%s\"\n",*message,sender);~~

~~- cursor=yahoo_strip_tattoo(*message);~~

~~- if(cursor!=*message){~~

~~- newmsg=g_strdup(cursor);~~

~~- g_free(*message);~~

~~- (*message)=newmsg;~~

~~- }~~

~~- text=g_string_new(*message);~~

~~- rv=apply_rule(conv,account,username,text,msgflags);~~

~~- if(rv)~~

~~- purple_debug_info("ignorance", "%s: %s violated!\n",username->str,text->str);~~

~~- g_string_free(username,TRUE);~~

~~- g_string_free(text,TRUE);~~

~~- purple_debug_info("ignorance","Returning from substitution\n");~~

~~- return rv;~~

~~-static gboolean chat_cb(PurpleAccount *account, gchar **sender, gchar **buffer,~~

~~- PurpleConversation *chat, void *data){~~

~~- return substitute(chat, account, *sender, buffer,~~

~~- IGNORANCE_APPLY_CHAT | IGNORANCE_APPLY_USER);~~

~~-static gboolean im_cb(PurpleAccount *account, gchar **sender, gchar **buffer,~~

~~- gint *flags, void *data){~~

~~- PurpleConversation *gc;~~

~~- gc=purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM,*sender,account);~~

~~- return substitute(gc, account, *sender,buffer,~~

~~- IGNORANCE_APPLY_IM | IGNORANCE_APPLY_USER);~~

~~-static gboolean chat_joinleave_cb (PurpleConversation *conv, const gchar *name,~~

~~- void *data){~~

~~- gchar *message=g_strdup(name);~~

~~- gboolean rv=substitute(conv, purple_conversation_get_account(conv), name,~~

~~- &message,IGNORANCE_APPLY_ENTERLEAVE | IGNORANCE_APPLY_USER);~~

~~- g_free(message);~~

~~- return rv;~~

~~-static gint chat_invited_cb(PurpleAccount *account,const gchar *inviter, const gchar *chat, const gchar *invite_message, const GHashTable *components, void *data){~~

~~- gchar *message=g_strdup(invite_message);~~

~~- gboolean rv;~~

~~- gint invite_ask=0;~~

~~- PurpleConversation *gc;~~

~~- g_free(message);~~

~~- gc=purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM,inviter,account);~~

~~- rv=substitute(gc,account,inviter,&message,IGNORANCE_APPLY_INVITE | IGNORANCE_APPLY_USER | IGNORANCE_APPLY_CHAT);~~

~~- if(rv)~~

~~- invite_ask=-1;~~

~~- return invite_ask;~~

~~-static void buddy_added_cb(PurpleBuddy *buddy, gpointer data){~~

~~- GString *wlname=g_string_new("WL");~~

~~- ignorance_level *wl=ignorance_get_level_name(wlname);~~

~~- PurpleAccount *account=buddy->account;~~

~~- gchar *name=(gchar*)buddy->name;~~

~~- purple_debug_info("ignorance","Caught buddy-added for %s%s\n",~~

~~- purple_account_get_protocol_id(account), name);~~

~~- purple_buddy_add(NULL,buddy,wl);~~

~~- g_string_free(wlname,TRUE);~~

~~-static void buddy_removed_cb(PurpleBuddy *buddy, gpointer data){~~

~~- GString *tmp=NULL;~~

~~- PurpleConversation *conv=NULL;~~

~~- PurpleAccount *account=buddy->account;~~

~~- gchar *name=(gchar*)buddy->name;~~

~~- tmp=g_string_new(purple_account_get_protocol_id(account));~~

~~- conv=purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM,tmp->str,account);~~

~~- purple_debug_info("ignorance","Caught buddy-removed for %s%s\n",~~

~~- purple_account_get_protocol_id(account), name);~~

~~- g_string_append(tmp,purple_normalize_nocase(account,name));~~

~~- ignorance_rm_user(conv,tmp->str);~~

~~- g_string_free(tmp,TRUE);~~

~~-static gboolean generate_default_levels() {~~

~~- ignorance_level *tmplvl;~~

~~- ignorance_rule *tmprule;~~

~~- GString *tmpgs;~~

~~- tmplvl=ignorance_level_new();~~

~~- tmplvl->name=g_string_new("Default");~~

~~- ignorance_add_level(tmplvl);~~

~~- tmplvl=ignorance_level_new();~~

~~- tmplvl->name=g_string_new("WL");~~

~~- ignorance_add_level(tmplvl);~~

~~- tmplvl=ignorance_level_new();~~

~~- tmplvl->name=g_string_new("BL");~~

~~- ignorance_add_level(tmplvl);~~

~~- tmpgs=g_string_new("Everything");~~

~~-#ifdef HAVE_REGEX_H~~

~~- tmprule=ignorance_rule_newp(tmpgs,IGNORANCE_RULE_REGEX,".*",~~

~~- IGNORANCE_FLAG_FILTER,~~

~~- IGNORANCE_APPLY_CHAT | IGNORANCE_APPLY_IM,~~

~~- TRUE,NULL,NULL,NULL);~~

~~-#else~~

~~- tmprule=ignorance_rule_newp(tmpgs,IGNORANCE_RULE_SIMPLETEXT,"",~~

~~- IGNORANCE_FLAG_FILTER,~~

~~- IGNORANCE_APPLY_CHAT | IGNORANCE_APPLY_IM,~~

~~- TRUE,NULL,NULL,NULL);~~

~~-#endif~~

~~- ignorance_level_add_rule(tmplvl,tmprule);~~

~~- g_string_free(tmpgs,TRUE);~~

~~- return TRUE;~~

~~-gboolean save_conf()~~

~~- FILE *f;~~

~~- gchar *name, tempfilename[BUF_LONG];~~

~~- gint fd, i;~~

~~- name = g_build_filename(purple_user_dir(), "ignorance", NULL);~~

~~- strcpy(tempfilename, name);~~

~~- strcat(tempfilename,".XXXXXX");~~

~~- fd = g_mkstemp(tempfilename);~~

~~- if(fd<0) {~~

~~- perror(tempfilename);~~

~~- g_free(name);~~

~~- return FALSE;~~

~~- }~~

~~- if (!(f = fdopen(fd, "w"))) {~~

~~- perror("fdopen");~~

~~- close(fd);~~

~~- g_free(name);~~

~~- return FALSE;~~

~~- }~~

~~- fchmod(fd, S_IRUSR | S_IWUSR);~~

~~- for(i=0;i<levels->len;++i){~~

~~- ignorance_level_write(g_ptr_array_index(levels,i),f);~~

~~- }~~

~~- if(fclose(f)) {~~

~~- purple_debug_error("ignorance",~~

~~- "Error writing to %s: %m\n", tempfilename);~~

~~- unlink(tempfilename);~~

~~- g_free(name);~~

~~- return FALSE;~~

~~- }~~

~~- rename(tempfilename, name);~~

~~- g_free(name);~~

~~- return TRUE;~~

~~-ignorance_level* ignorance_get_level_name(const GString *levelname){~~

~~- gint i=0;~~

~~- ignorance_level *il=NULL;~~

~~- for(i=0;i<levels->len;++i){~~

~~- il=(ignorance_level*)g_ptr_array_index(levels,i);~~

~~- if(g_string_equal(levelname,il->name))~~

~~- return il;~~

~~- }~~

~~- return NULL;~~

~~-gboolean ignorance_add_level(ignorance_level *level){~~

~~- gboolean rv=FALSE;~~

~~- if(level){~~

~~- g_ptr_array_add(levels,level);~~

~~- rv=TRUE;~~

~~- }~~

~~- return rv;~~

~~-gboolean ignorance_remove_level(const GString *levelname){~~

~~- ignorance_level *level=ignorance_get_level_name(levelname);~~

~~- gboolean rv=FALSE;~~

~~- if(level){~~

~~- rv=g_ptr_array_remove(levels,level);~~

~~- ignorance_level_free(level);~~

~~- }~~

~~- return rv;~~

~~-static void~~

~~-ignorance_signals_connect(PurplePlugin *plugin)~~

~~- void *conv_handle, *blist_handle;~~

~~- conv_handle = purple_conversations_get_handle();~~

~~- blist_handle = purple_blist_get_handle();~~

~~- purple_signal_connect(conv_handle, "receiving-im-msg", plugin,~~

~~- PURPLE_CALLBACK (im_cb), NULL);~~

~~- purple_signal_connect(conv_handle, "receiving-chat-msg", plugin,~~

~~- PURPLE_CALLBACK (chat_cb), NULL);~~

~~- purple_signal_connect(conv_handle,"chat-buddy-joining", plugin,~~

~~- PURPLE_CALLBACK(chat_joinleave_cb),NULL);~~

~~- purple_signal_connect(conv_handle,"chat-buddy-leaving", plugin,~~

~~- PURPLE_CALLBACK(chat_joinleave_cb),NULL);~~

~~- purple_signal_connect(conv_handle,"chat-invited", plugin,~~

~~- PURPLE_CALLBACK(chat_invited_cb),NULL);~~

~~- purple_signal_connect(blist_handle,"buddy-added", plugin,~~

~~- PURPLE_CALLBACK(buddy_added_cb),NULL);~~

~~- purple_signal_connect(blist_handle,"buddy-removed", plugin,~~

~~- PURPLE_CALLBACK(buddy_removed_cb),NULL);~~

~~- return;~~

~~-static gboolean load_conf() {~~

~~- gchar *buf, *ibuf;~~

~~- gint pnt = 0;~~

~~- gsize size;~~

~~- FILE *conffile = NULL;~~

~~- static ignorance_level *tmplvl = NULL;~~

~~- static ignorance_rule *tmprule = NULL;~~

~~- GString *tmpgs = NULL;~~

~~- buf = g_build_filename(purple_user_dir(), "ignorance", NULL);~~

~~- purple_debug_info("ignorance", "Attempting to load conf file %s\n",buf);~~

~~- levels = g_ptr_array_new();~~

~~- if(!(conffile = fopen(buf, "r"))) {~~

~~- g_free(buf);~~

~~- buf=g_build_filename(IGNORANCE_CONFDIR,"ignorance.conf",NULL);~~

~~- if(!(conffile = fopen(buf,"r"))) {~~

~~- purple_debug_info("ignorance",~~

~~- "Unable to open local or global conf files; falling back to defaults\n");~~

~~- generate_default_levels();~~

~~- import_purple_list();~~

~~- import_zinc_list();~~

~~- import_curphoo_list();~~

~~- g_free(buf);~~

~~- return FALSE;~~

~~- }~~

~~- g_file_get_contents(buf, &ibuf, &size, NULL);~~

~~- fclose(conffile);~~

~~- g_free(buf);~~

~~- if(!ibuf) {~~

~~- generate_default_levels();~~

~~- import_purple_list();~~

~~- import_zinc_list();~~

~~- import_curphoo_list();~~

~~- return FALSE;~~

~~- }~~

~~- while(buf_get_line(ibuf, &buf, &pnt, size)) {~~

~~- if((*buf) == '#'){~~

~~- /* ignore */~~

~~- } else if(strstr(buf, "level")){~~

~~- if('\0' == buf[5]){~~

~~- tmpgs = g_string_new("");~~

~~- for( ; buf != strstr(buf, "/level");~~

~~- buf_get_line(ibuf, &buf, &pnt, size))~~

~~- {~~

~~- g_string_append(tmpgs, buf);~~

~~- g_string_append(tmpgs, "\n");~~

~~- }~~

~~- tmplvl = ignorance_level_read(tmpgs->str);~~

~~- g_string_free(tmpgs, TRUE);~~

~~- } else~~

~~- tmplvl=ignorance_level_read(buf);~~

~~- if(tmplvl) {~~

~~- purple_debug_info("ignorance", "Adding level %s\n",~~

~~- tmplvl->name->str);~~

~~- ignorance_add_level(tmplvl);~~

~~- }~~

~~- } else if(strstr(buf, "rule") && tmplvl) {~~

~~- if('\0' == buf[4]) {~~

~~- tmpgs = g_string_new("");~~

~~- for( ; buf != strstr(buf, "/rule");~~

~~- buf_get_line(ibuf, &buf, &pnt, size))~~

~~- {~~

~~- g_string_append(tmpgs, buf);~~

~~- g_string_append(tmpgs, "\n");~~

~~- }~~

~~- purple_debug_info("ignorance", "Attempting to read rule %s\n",~~

~~- tmpgs->str);~~

~~- tmprule = ignorance_rule_read(tmpgs->str);~~

~~- g_string_free(tmpgs, TRUE);~~

~~- } else~~

~~- tmprule = ignorance_rule_read(buf);~~

~~- if(tmprule) {~~

~~- purple_debug_info("ignorance", "Adding rule %s: %s\n",~~

~~- tmprule->name->str, (gchar*)(tmprule->value));~~

~~- ignorance_level_add_rule(tmplvl, tmprule);~~

~~- }~~

~~- } else if(tmplvl) {~~

~~- tmpgs = g_string_new(purple_normalize_nocase(NULL, buf));~~

~~- purple_debug_info("ignorance", "Adding denizen %s\n", buf);~~

~~- if(ignorance_get_user_level(tmpgs) == ignorance_get_default_level())~~

~~- ignorance_level_add_denizen(tmplvl, tmpgs);~~

~~- g_string_free(tmpgs,TRUE);~~

~~- }~~

~~- g_free(ibuf);~~

~~- import_purple_list();~~

~~- import_zinc_list();~~

~~- import_curphoo_list();~~

~~- return TRUE;~~

~~-static gboolean~~

~~-ignorance_load (PurplePlugin *plugin) {~~

~~- purple_debug_info("ignorance", "Loading ignorance plugin");~~

~~- load_conf();~~

~~- ignorance_signals_connect(plugin);~~

~~- return TRUE;~~

~~-static gboolean~~

~~-plugin_unload(PurplePlugin *plugin) {~~

~~- purple_debug_info("ignorance", "Unloading ignorance plugin\n");~~

~~- save_conf();~~

~~- return TRUE;~~

~~-static GtkWidget *get_config_frame(PurplePlugin *plugin) {~~

~~- return create_uiinfo(levels);~~

~~-static PidginPluginUiInfo ui_info = {~~

~~- get_config_frame,~~

~~- 0,~~

~~- NULL,~~

~~- NULL~~

~~-};~~

~~-static PurplePluginInfo ig_info = {~~

~~- PURPLE_PLUGIN_MAGIC,~~

~~- PURPLE_MAJOR_VERSION,~~

~~- PURPLE_MINOR_VERSION,~~

~~- PURPLE_PLUGIN_STANDARD,~~

~~- PIDGIN_PLUGIN_TYPE,~~

~~- 0,~~

~~- NULL,~~

~~- PURPLE_PRIORITY_DEFAULT,~~

~~- IGNORANCE_PLUGIN_ID,~~

~~- NULL,~~

~~- PP_VERSION,~~

~~- NULL,~~

~~- "Peter Lawler <bleeter from users.sf.net>, "~~

~~- "Levi Bard <taktaktaktaktaktaktaktaktaktak@gmail.com> (original author)",~~

~~- "http://guifications.sourceforge.net",~~

~~- ignorance_load,~~

~~- plugin_unload,~~

~~- NULL,~~

~~- &ui_info,~~

~~- NULL,~~

~~- NULL~~

~~-};~~

~~-static void~~

~~-ignorance_init (PurplePlugin * plugin)~~

~~-#ifdef ENABLE_NLS~~

~~- bindtextdomain(GETTEXT_PACKAGE, PP_LOCALEDIR);~~

~~- bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");~~

~~-#endif /* ENABLE_NLS */~~

~~- ig_info.name = _("Ignorance");~~

~~- ig_info.summary =~~

~~- _("Allows you to manage lists of users with various levels of allowable activity.");~~

~~- ig_info.description =~~

~~- _("Allows you to manage lists of users with various levels of allowable activity.");~~

~~-PURPLE_INIT_PLUGIN (ignorance, ignorance_init, ig_info)~~

~~--- a/ignorance/ignorance.conf Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,20 +0,0 @@

~~-level index="100" name="Default" upper_threshhold="10" lower_threshhold="-10" allow_passthrough="0"~~

~~-rule name="link" type="1" score="1" value="http://" flags="3" enabled="0"~~

~~-rule name="PM" type="2" score="1" value="." flags="2" enabled="1"~~

~~-rule name="playing" type="2" score="1" value="[Pp]laying" flags="3" enabled="0"~~

~~-rule name="enterleave" type="2" score="1" value="." flags="16" enabled="1"~~

~~-rule name="invite" type="2" score="1" value="." flags="32" enabled="1"~~

~~-rule name="profilebot" type="1" score="1" value="profile" flags="4" enabled="1"~~

~~-level index="1" name="WL" upper_threshhold="10" lower_threshhold="-10" allow_passthrough="0"~~

~~-level index="80" name="PM" upper_threshhold="10" lower_threshhold="-10" allow_passthrough="0"~~

~~-rule name="enterleave" type="2" score="1" value="." flags="16" enabled="1"~~

~~-level index="90" name="Link" upper_threshhold="10" lower_threshhold="-10" allow_passthrough="0"~~

~~-rule name="PM" type="2" score="1" value="." flags="2" enabled="1"~~

~~-rule name="enterleave" type="2" score="1" value="." flags="16" enabled="1"~~

~~-rule name="playing" type="2" score="1" value="[Pp]laying" flags="3" enabled="0"~~

~~-rule name="invite" type="2" score="1" value="." flags="32" enabled="1"~~

~~-level index="1001" name="BL" upper_threshhold="10" lower_threshhold="-10" allow_passthrough="0"~~

~~-rule name="everything" type="2" score="1" value="." flags="55" enabled="1"~~

~~-level index="999" name="ZincBL" upper_threshhold="9" lower_threshhold="-9" allow_passthrough="0"~~

~~-rule name="Everything" type="2" score="1" value="." flags="3" enabled="1"~~

~~-level index="2" name="ZincWL" upper_threshhold="9" lower_threshhold="-9" allow_passthrough="0"~~

~~--- a/ignorance/ignorance.h Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,45 +0,0 @@

-/*

~~- * This program is free software; you can redistribute it and/or~~

~~- * modify it under the terms of the GNU General Public License~~

~~- * as published by the Free Software Foundation; either version 2~~

~~- * of the License, or (at your option) any later version.~~

- *

~~- * This program is distributed in the hope that it will be useful,~~

~~- * but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- * GNU General Public License for more details.~~

- *

~~- * You should have received a copy of the GNU General Public License~~

~~- * along with this program; if not, write to the Free Software~~

~~- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.~~

~~- */~~

~~-#ifndef IGNORANCE_H~~

~~-#define IGNORANCE_H~~

~~-#ifdef HAVE_CONFIG_H~~

~~-# include "../pp_config.h"~~

~~-#endif~~

~~-#include "../common/pp_internal.h"~~

~~-#include "ignorance_level.h"~~

~~-#define IGNORANCE_APPLY_CHAT 1~~

~~-#define IGNORANCE_APPLY_IM 2~~

~~-#define IGNORANCE_APPLY_USER 4~~

~~-#define IGNORANCE_APPLY_HOST 8~~

~~-#define IGNORANCE_APPLY_ENTERLEAVE 16~~

~~-#define IGNORANCE_APPLY_INVITE 32~~

~~-ignorance_level* ignorance_get_level_name(const GString *levelname);~~

~~-gboolean ignorance_add_level(ignorance_level *level);~~

~~-gboolean ignorance_remove_level(const GString *levelname);~~

~~-gint ignorance_get_new_level_index();~~

~~-gboolean save_conf();~~

~~-#endif~~

~~--- a/ignorance/ignorance_denizen.c Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,62 +0,0 @@

-/*

~~- * This program is free software; you can redistribute it and/or~~

~~- * modify it under the terms of the GNU General Public License~~

~~- * as published by the Free Software Foundation; either version 2~~

~~- * of the License, or (at your option) any later version.~~

- *

~~- * This program is distributed in the hope that it will be useful,~~

~~- * but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- * GNU General Public License for more details.~~

- *

~~- * You should have received a copy of the GNU General Public License~~

~~- * along with this program; if not, write to the Free Software~~

~~- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.~~

~~- */~~

~~-#include "ignorance_denizen.h"~~

~~-#include "ignorance_internal.h"~~

~~-ignorance_denizen* ignorance_denizen_new(const gchar *newname) {~~

~~- ignorance_denizen *id=(ignorance_denizen*)g_malloc(sizeof(ignorance_denizen));~~

~~- id->name=g_strdup(newname);~~

~~- id->last_message=g_strdup("");~~

~~- id->repeats=0;~~

~~- return id;~~

~~-void ignorance_denizen_free(ignorance_denizen *id) {~~

~~- g_free(id->name);~~

~~- g_free(id->last_message);~~

~~- g_free(id);~~

~~-gchar *ignorance_denizen_get_name(ignorance_denizen *id) {~~

~~- return id->name;~~

~~-gchar *ignorance_denizen_get_last_message(ignorance_denizen *id) {~~

~~- return id->last_message;~~

~~-gint ignorance_denizen_get_repeats(ignorance_denizen *id) {~~

~~- return id->repeats;~~

~~-gint ignorance_denizen_set_message(ignorance_denizen *id, const gchar *message) {~~

~~- if(!strcasecmp(id->last_message,message)){~~

~~- purple_debug_info("ignorance","Got repeat %d for message %s\n",~~

~~- id->repeats+1,message);~~

~~- id->repeats++;~~

~~- } else {~~

~~- purple_debug_info("ignorance","New message %s replacing old message %s",~~

~~- message,id->last_message);~~

~~- g_free(id->last_message);~~

~~- id->last_message=g_strdup(message);~~

~~- id->repeats=0;~~

~~- }~~

~~- return id->repeats;~~

~~--- a/ignorance/ignorance_denizen.h Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,42 +0,0 @@

-/*

~~- * This program is free software; you can redistribute it and/or~~

~~- * modify it under the terms of the GNU General Public License~~

~~- * as published by the Free Software Foundation; either version 2~~

~~- * of the License, or (at your option) any later version.~~

- *

~~- * This program is distributed in the hope that it will be useful,~~

~~- * but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- * GNU General Public License for more details.~~

- *

~~- * You should have received a copy of the GNU General Public License~~

~~- * along with this program; if not, write to the Free Software~~

~~- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.~~

~~- */~~

~~-#ifndef IGNORANCE_DENIZEN_H~~

~~-#define IGNORANCE_DENIZEN_H~~

~~-#include <string.h>~~

~~-#include "ignorance.h"~~

~~-typedef struct ignorance_denizen{~~

~~- gchar *name;~~

~~- gchar *last_message;~~

~~- gint repeats;~~

~~-} ignorance_denizen;~~

~~-ignorance_denizen* ignorance_denizen_new(const gchar *newname);~~

~~-void ignorance_denizen_free(ignorance_denizen *denizen);~~

~~-gchar* ignorance_denizen_get_name(ignorance_denizen *id);~~

~~-gchar* ignorance_denizen_get_last_message(ignorance_denizen *id);~~

~~-gint ignorance_denizen_get_repeats(ignorance_denizen *id);~~

~~-gint ignorance_denizen_set_message(ignorance_denizen *id, const gchar *message);~~

~~-#endif~~

~~--- a/ignorance/ignorance_internal.h Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,72 +0,0 @@

-/*

~~- * Guifications - The end all, be all, toaster popup plugin~~

- *

~~- * This program is free software; you can redistribute it and/or~~

~~- * modify it under the terms of the GNU General Public License~~

~~- * as published by the Free Software Foundation; either version 2~~

~~- * of the License, or (at your option) any later version.~~

- *

~~- * This program is distributed in the hope that it will be useful,~~

~~- * but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- * GNU General Public License for more details.~~

- *

~~- * You should have received a copy of the GNU General Public License~~

~~- * along with this program; if not, write to the Free Software~~

~~- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.~~

~~- */~~

~~-#ifndef IG_INTERNAL_H~~

~~-#define IG_INTERNAL_H~~

~~-#include <glib.h>~~

~~-#define IGNORANCE_PLUGIN_ID "gtk-bleeter-ignorance"~~

~~-#define SHORTDESC "Ignorance filter"~~

~~-#ifndef IGNORANCE_CONFDIR~~

~~-# define IGNORANCE_CONFDIR purple_user_dir()~~

~~-#endif~~

~~-#define EXEC_TIMEOUT 10~~

~~-#define GREATER(x,y) ((x)?((x)>(y)):(y))~~

~~-#if ((PURPLE_MAJOR_VERSION) < 2)~~

~~-#define PURPLE_CONV_TYPE_CHAT PURPLE_CONV_CHAT~~

~~-#define PURPLE_CONV_TYPE_IM PURPLE_CONV_IM~~

~~-#endif~~

~~-#if GLIB_CHECK_VERSION(2,6,0)~~

~~-# include <glib/gstdio.h>~~

~~-#endif~~

~~-#ifdef _WIN32~~

~~-# include <win32dep.h>~~

~~-#endif~~

~~-#if !GLIB_CHECK_VERSION(2,6,0)~~

~~-# define g_freopen freopen~~

~~-# define g_fopen fopen~~

~~-# define g_rmdir rmdir~~

~~-# define g_remove remove~~

~~-# define g_unlink unlink~~

~~-# define g_lstat lstat~~

~~-# define g_stat stat~~

~~-# define g_mkdir mkdir~~

~~-# define g_rename rename~~

~~-# define g_open open~~

~~-#endif~~

~~-#ifdef HAVE_ENDIAN_H~~

~~-# include <endian.h>~~

~~-#endif~~

~~-#define MSG_LEN 2048~~

~~-/* The above should normally be the same as BUF_LEN,~~

~~- * but just so we're explicitly asking for the max message~~

~~- * length. */~~

~~-#define BUF_LEN MSG_LEN~~

~~-#define BUF_LONG BUF_LEN * 2~~

~~-#endif~~

~~--- a/ignorance/ignorance_level.c Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,328 +0,0 @@

-/*

~~- * This program is free software; you can redistribute it and/or~~

~~- * modify it under the terms of the GNU General Public License~~

~~- * as published by the Free Software Foundation; either version 2~~

~~- * of the License, or (at your option) any later version.~~

- *

~~- * This program is distributed in the hope that it will be useful,~~

~~- * but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- * GNU General Public License for more details.~~

- *

~~- * You should have received a copy of the GNU General Public License~~

~~- * along with this program; if not, write to the Free Software~~

~~- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.~~

~~- */~~

~~-#include "ignorance.h"~~

~~-#include "ignorance_denizen.h"~~

~~-#include "ignorance_internal.h"~~

~~-#include "ignorance_level.h"~~

~~-#include "ignorance_violation.h"~~

~~-#include "regex.h"~~

~~-#include <string.h>~~

~~-#include <strings.h>~~

~~-void ignorance_level_write_hashitem(gpointer key, gpointer value,~~

~~- gpointer user_data);~~

~~-void ignorance_hash_free(gpointer key, gpointer value,~~

~~- gpointer user_data);~~

~~-void ignorance_level_regex_hashitem(gpointer key, gpointer value,~~

~~- gpointer user_data);~~

~~-gboolean assign_level_token(ignorance_level *lvl,const gchar *tokentxt);~~

~~-gint g_string_compare(gconstpointer a, gconstpointer z);~~

~~-ignorance_level* ignorance_level_new() {~~

~~- ignorance_level *il=(ignorance_level*)g_malloc(sizeof(ignorance_level));~~

~~- il->name=g_string_new("Default");~~

~~- il->denizens_hash=g_hash_table_new(g_str_hash,g_str_equal);~~

~~- il->rules=g_ptr_array_new();~~

~~- return il;~~

~~-void ignorance_level_free(ignorance_level *il) {~~

~~- g_string_free(il->name,TRUE);~~

~~- g_hash_table_foreach(il->denizens_hash,ignorance_hash_free,NULL);~~

~~- g_hash_table_destroy(il->denizens_hash);~~

~~- g_ptr_array_foreach(il->rules,ignorance_rule_free_g,NULL);~~

~~-void ignorance_level_free_g(gpointer il,gpointer user_data) {~~

~~- ignorance_level_free((ignorance_level*)il);~~

~~-gboolean ignorance_level_add_rule(ignorance_level *level,ignorance_rule *rule) {~~

~~- g_ptr_array_add(level->rules,(gpointer)rule);~~

~~- return TRUE;~~

~~-ignorance_rule* ignorance_level_get_rule(ignorance_level *level,~~

~~- const GString *rulename) {~~

~~- int i=0;~~

~~- ignorance_rule *rule=NULL;~~

~~- for(i=0;i<level->rules->len;++i){~~

~~- rule=g_ptr_array_index(level->rules,i);~~

~~- if(g_string_equal(rulename,rule->name))~~

~~- return g_ptr_array_index(level->rules,i);~~

~~- }~~

~~- return NULL;~~

~~-gboolean ignorance_level_remove_rule(ignorance_level *level,~~

~~- const GString *rulename) {~~

~~- return g_ptr_array_remove_fast(level->rules,~~

~~- ignorance_level_get_rule(level,rulename));~~

~~-gboolean ignorance_level_add_denizen(ignorance_level *level,~~

~~- const GString *username) {~~

~~- if(!g_hash_table_lookup(level->denizens_hash,username->str)){~~

~~- ignorance_denizen *id=ignorance_denizen_new(username->str);~~

~~- g_hash_table_insert(level->denizens_hash,~~

~~- ignorance_denizen_get_name(id),id);~~

~~- }~~

~~- return TRUE;~~

~~-#ifdef HAVE_REGEX_H~~

~~-gboolean ignorance_level_has_denizen_regex(ignorance_level *level,~~

~~- const gchar *regex, GList **denizens) {~~

~~- regex_t reg;~~

~~- gpointer udata[2];~~

~~- udata[0]=denizens;~~

~~- if(regcomp(&reg,regex,REG_EXTENDED | REG_NOSUB)) {~~

~~- purple_debug_error("ignorance", "Error parsing regex %s\n",~~

~~- regex);~~

~~- regfree(&reg);~~

~~- return FALSE;~~

~~- }~~

~~- udata[1]=®~~

~~- g_hash_table_foreach(level->denizens_hash,ignorance_level_regex_hashitem,~~

~~- (gpointer)udata);~~

~~- regfree(&reg);~~

~~- return (denizens!=NULL);~~

~~-#endif~~

~~-gboolean ignorance_level_has_denizen(ignorance_level *level,~~

~~- const GString *username) {~~

~~- gboolean rv=FALSE;~~

~~- rv = (NULL != g_hash_table_lookup(level->denizens_hash,username->str));~~

~~- return rv;~~

~~-gint g_string_compare(gconstpointer a, gconstpointer z) {~~

~~- const GString *gsa=(const GString*)a, *gsz=(const GString*)z;~~

~~- return g_ascii_strcasecmp(gsa->str, gsz->str);~~

~~-gboolean ignorance_level_remove_denizen(ignorance_level *level,~~

~~- const GString *username) {~~

~~- gpointer kptr=NULL, vptr=NULL;~~

~~- gboolean rv=FALSE;~~

~~- rv=g_hash_table_lookup_extended(level->denizens_hash, username->str, &kptr,~~

~~- &vptr);~~

~~- purple_debug_info("ignorance","Remove: found id %x\n",vptr);~~

~~- if(rv){~~

~~- purple_debug_info("ignorance","Removing from hash\n");~~

~~- g_hash_table_remove(level->denizens_hash,username->str);~~

~~- purple_debug_info("ignorance","Freeing denizen\n");~~

~~- ignorance_denizen_free((ignorance_denizen*)vptr);~~

~~- purple_debug_info("ignorance","Done freeing denizen\n");~~

~~- }~~

~~- return rv;~~

~~-gint ignorance_level_rulecheck(ignorance_level *level,~~

~~- const GString *username, const GString *text,~~

~~- gint flags, GList **violations) {~~

~~- int i=0, totalscore=0, curscore;~~

~~- ignorance_rule *cur;~~

~~- ignorance_denizen *id;~~

~~- purple_debug_info("ignorance","Preparing to lookup %s\n", username->str);~~

~~- id = g_hash_table_lookup(level->denizens_hash, username->str);~~

~~- purple_debug_info("ignorance","Got denizen %x\n",id);~~

~~- if(id){~~

~~- purple_debug_info("ignorance","Making sure text isn't name\n");~~

~~- if(strcasecmp(ignorance_denizen_get_name(id),text->str)){~~

~~- purple_debug_info("ignorance","Setting new message to %s\n", text->str);~~

~~- ignorance_denizen_set_message(id, text->str);~~

~~- }~~

~~- for(i=0;i<level->rules->len;++i) {~~

~~- cur=(ignorance_rule*)g_ptr_array_index(level->rules,i);~~

~~- if(cur->flags & IGNORANCE_APPLY_USER) {~~

~~- curscore=ignorance_rule_rulecheck(cur,username,flags);~~

~~- totalscore|=curscore;~~

~~- if(curscore){~~

~~- if(curscore & IGNORANCE_FLAG_MESSAGE)~~

~~- (*violations)=g_list_prepend(*violations,~~

~~- ignorance_violation_newp(IGNORANCE_FLAG_MESSAGE,~~

~~- cur->message));~~

~~- if(curscore & IGNORANCE_FLAG_SOUND)~~

~~- (*violations)=g_list_prepend(*violations,~~

~~- ignorance_violation_newp(IGNORANCE_FLAG_SOUND,~~

~~- cur->sound));~~

~~- if(curscore & IGNORANCE_FLAG_EXECUTE)~~

~~- (*violations)=g_list_prepend(*violations,~~

~~- ignorance_violation_newp(IGNORANCE_FLAG_EXECUTE,~~

~~- cur->command));~~

~~- }~~

~~- curscore=ignorance_rule_rulecheck(cur, text,~~

~~- flags & (~IGNORANCE_APPLY_USER));~~

~~- totalscore|=curscore;~~

~~- if(curscore){~~

~~- if(curscore & IGNORANCE_FLAG_MESSAGE)~~

~~- (*violations)=g_list_prepend(*violations,~~

~~- ignorance_violation_newp(IGNORANCE_FLAG_MESSAGE, cur->message));~~

~~- if(curscore & IGNORANCE_FLAG_SOUND)~~

~~- (*violations)=g_list_prepend(*violations,~~

~~- ignorance_violation_newp(IGNORANCE_FLAG_SOUND, cur->sound));~~

~~- if(curscore & IGNORANCE_FLAG_EXECUTE)~~

~~- (*violations)=g_list_prepend(*violations,~~

~~- ignorance_violation_newp(IGNORANCE_FLAG_EXECUTE, cur->command));~~

~~- }~~

~~- return totalscore;~~

~~-ignorance_level* ignorance_level_read_old(const gchar *lvltext) {~~

~~- gchar *tokptr=strchr((gchar*)lvltext,' '), **tokens=NULL;~~

~~- ignorance_level *lvl=ignorance_level_new();~~

~~- int i=0;~~

~~- if(!tokptr){~~

~~- ignorance_level_free(lvl);~~

~~- return NULL;~~

~~- }~~

~~- tokens=g_strsplit(lvltext," ",INT_MAX);~~

~~- for(i=0;tokens[i];++i)~~

~~- assign_level_token(lvl,tokens[i]);~~

~~- g_strfreev(tokens);~~

~~- return lvl;~~

~~-ignorance_level* ignorance_level_read(const gchar *lvltext) {~~

~~- gchar *tokptr=strchr((gchar*)lvltext,'\n'), **tokens=NULL;~~

~~- ignorance_level *lvl=ignorance_level_new();~~

~~- int i=0;~~

~~- if(!tokptr){~~

~~- ignorance_level_free(lvl);~~

~~- return ignorance_level_read_old(lvltext);~~

~~- }~~

~~- tokens=g_strsplit(lvltext,"\n",INT_MAX);~~

~~- for(i=0;tokens[i];++i)~~

~~- assign_level_token(lvl,tokens[i]);~~

~~- g_strfreev(tokens);~~

~~- return lvl;~~

~~-/* Parses out a token of the form tokenname="value" and assigns it to a rulename~~

- *

~~- * rule is the rule to be updated~~

~~- * tokentxt is the token string~~

~~- * true returned if token is valid and successfully added to the rule~~

- *

~~- * level name1="value1" name2="value2" ...~~

~~- */~~

~~-gboolean assign_level_token(ignorance_level *lvl,const gchar *tokentxt) {~~

~~- gchar *name=NULL, *value=NULL;~~

~~- gboolean rv=TRUE;~~

~~- gint cursor=0;~~

~~- value=strchr(tokentxt,'=');~~

~~- if(value) {~~

~~- (*value)='\0';~~

~~- ++value;~~

~~- if('"'==(*value)) {~~

~~- ++value;~~

~~- cursor=strlen(value)-1;~~

~~- if('"'==value[cursor])~~

~~- value[cursor]='\0';~~

~~- }~~

~~- name=(gchar*)tokentxt;~~

~~- if(!strncasecmp(name,"name",BUFSIZ))~~

~~- g_string_assign(lvl->name,value);~~

~~- else~~

~~- rv=FALSE;~~

~~- } else~~

~~- rv=FALSE;~~

~~- return rv;~~

~~-gboolean ignorance_level_write(ignorance_level *level,FILE *f) {~~

~~- gint i;~~

~~- fprintf(f,"level\nname=\"%s\"\n/level\n", level->name->str);~~

~~- for(i=0;i<level->rules->len;++i)~~

~~- ignorance_rule_write(g_ptr_array_index(level->rules,i),f);~~

~~- g_hash_table_foreach(level->denizens_hash,ignorance_level_write_hashitem,f);~~

~~- return TRUE;~~

~~-void ignorance_level_regex_hashitem(gpointer key, gpointer value,~~

~~- gpointer user_data) {~~

~~- gpointer *udata=(gpointer*)user_data;~~

~~- GList **denizens=(GList**)udata[0];~~

~~- if(!(regexec((regex_t*)udata[1],(gchar*)key,1,NULL,0)))~~

~~- (*denizens)=g_list_prepend(*denizens,g_string_new((gchar*)key));~~

~~-void ignorance_hash_free(gpointer key, gpointer value, gpointer user_data) {~~

~~- ignorance_denizen_free((ignorance_denizen*)value);~~

~~-void ignorance_level_write_hashitem(gpointer key, gpointer value,~~

~~- gpointer user_data){~~

~~- fprintf((FILE*)user_data,"%s\n",(gchar*)key);~~

~~--- a/ignorance/ignorance_level.h Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,99 +0,0 @@

-/*

~~- * This program is free software; you can redistribute it and/or~~

~~- * modify it under the terms of the GNU General Public License~~

~~- * as published by the Free Software Foundation; either version 2~~

~~- * of the License, or (at your option) any later version.~~

- *

~~- * This program is distributed in the hope that it will be useful,~~

~~- * but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- * GNU General Public License for more details.~~

- *

~~- * You should have received a copy of the GNU General Public License~~

~~- * along with this program; if not, write to the Free Software~~

~~- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.~~

~~- */~~

~~-#ifndef IGNORANCE_LEVEL_H~~

~~-#define IGNORANCE_LEVEL_H~~

~~-#include "ignorance_rule.h"~~

-/*

~~- * describes an ignorance level~~

- *

~~- * index is an index for keeping track~~

~~- * of levels' relative positions~~

~~- * the idea is for 0 to be the "default" level,~~

~~- * >0 to be "better" levels, and <0 to be "worse"~~

- *

~~- * allow_passthrough flags whether a user~~

~~- * is allowed to be "passed through" this level~~

~~- * to the next consecutive level, as in:~~

~~- * if someone on my friends list does something~~

~~- * that flags 12 of my rules, do I send them~~

~~- * straight to /dev/null, or just~~

~~- * bump them down a level?~~

- *

~~- * name - user's name for the level~~

- *

~~- * denizens - list of users in this level~~

~~- * I may get rid of this in favor of a more global~~

~~- * userlist~~

- *

~~- * rules - list of rules for this level~~

~~- */~~

~~-typedef struct ignorance_level{~~

~~- GString *name;~~

~~- /*GList *denizens;*/~~

~~- GHashTable *denizens_hash;~~

~~- GPtrArray *rules;~~

~~-} ignorance_level;~~

~~-ignorance_level* ignorance_level_new();~~

~~-void ignorance_level_free(ignorance_level *il);~~

~~-void ignorance_level_free_g(gpointer il,gpointer user_data);~~

~~-gboolean ignorance_level_add_rule(ignorance_level *level,ignorance_rule *rule);~~

~~-ignorance_rule* ignorance_level_get_rule(ignorance_level *level,~~

~~- const GString *rulename);~~

~~-gboolean ignorance_level_remove_rule(ignorance_level *level,~~

~~- const GString *rulename);~~

~~-gboolean ignorance_level_add_denizen(ignorance_level *level,~~

~~- const GString *username);~~

~~-gboolean ignorance_level_add_denizen_fast(ignorance_level *level,~~

~~- const GString *username);~~

~~-gboolean ignorance_level_has_denizen(ignorance_level *level,~~

~~- const GString *username);~~

~~-#ifdef HAVE_REGEX_H~~

~~-gboolean ignorance_level_has_denizen_regex(ignorance_level *level,~~

~~- const gchar *regex, GList **denizens);~~

~~-#endif~~

~~-gboolean ignorance_level_remove_denizen(ignorance_level *level,~~

~~- const GString *username);~~

-/*

~~- * Determines whether a string violates one of~~

~~- * the rules defined in an ignorance level~~

- *

~~- * il is the ignorance level~~

~~- * text is the possibly offending string~~

~~- * flags are the rule flags to match~~

~~- * returns score~~

~~- */~~

~~-gint ignorance_level_rulecheck(ignorance_level *il,const GString *username,~~

~~- const GString *text, gint flags,~~

~~- GList **violations);~~

~~-ignorance_level* ignorance_level_read(const gchar *lvltext);~~

~~-gboolean ignorance_level_write(ignorance_level *level,FILE *f);~~

~~-#endif~~

~~--- a/ignorance/ignorance_rule.c Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,243 +0,0 @@

-/*

~~- * This program is free software; you can redistribute it and/or~~

~~- * modify it under the terms of the GNU General Public License~~

~~- * as published by the Free Software Foundation; either version 2~~

~~- * of the License, or (at your option) any later version.~~

- *

~~- * This program is distributed in the hope that it will be useful,~~

~~- * but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- * GNU General Public License for more details.~~

- *

~~- * You should have received a copy of the GNU General Public License~~

~~- * along with this program; if not, write to the Free Software~~

~~- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.~~

~~- */~~

~~-#include "ignorance_rule.h"~~

~~-#include <string.h>~~

~~-#include <strings.h>~~

~~-#include "ignorance_internal.h"~~

~~-gboolean assign_rule_token(ignorance_rule *rule, const char *tokentxt);~~

~~-ignorance_rule* ignorance_rule_new() {~~

~~- ignorance_rule *ir=(ignorance_rule*)g_malloc(sizeof(ignorance_rule));~~

~~- ir->name=g_string_new("");~~

~~- ir->type=IGNORANCE_RULE_SIMPLETEXT;~~

~~- ir->score=0;~~

~~- ir->flags=0;~~

~~- ir->enabled=TRUE;~~

~~- ir->value=NULL;~~

~~- ir->message=NULL;~~

~~- ir->sound=NULL;~~

~~- ir->command=NULL;~~

~~- return ir;~~

~~-ignorance_rule* ignorance_rule_newp(const GString *name, gint type,~~

~~- const gchar *value, gint score, gint flags,~~

~~- gboolean enabled, const gchar *message,~~

~~- const gchar *sound, const gchar *command) {~~

~~- ignorance_rule *ir=(ignorance_rule*)g_malloc(sizeof(ignorance_rule));~~

~~- ir->name=g_string_new(name->str);~~

~~- if(ignorance_rule_has_type(type))~~

~~- ir->type=type;~~

~~- else~~

~~- ir->type=IGNORANCE_RULE_INVALID;~~

~~- ir->value=g_strdup(value);~~

~~- ir->score=score;~~

~~- ir->flags=flags;~~

~~- ir->enabled=enabled;~~

~~- ir->message=g_strdup(message);~~

~~- ir->sound=g_strdup(sound);~~

~~- ir->command=g_strdup(command);~~

~~- return ir;~~

~~-void ignorance_rule_free(ignorance_rule *ir) {~~

~~- g_string_free(ir->name,TRUE);~~

~~- g_free(ir->value);~~

~~- g_free(ir->message);~~

~~- g_free(ir->sound);~~

~~- g_free(ir->command);~~

~~- g_free(ir);~~

~~-void ignorance_rule_free_g(gpointer ir,gpointer user_data) {~~

~~- ignorance_rule_free((ignorance_rule*)ir);~~

~~-gboolean ignorance_rule_has_type(gint type) {~~

~~- if((type>=IGNORANCE_RULE_MINVALID) || (type<=IGNORANCE_RULE_INVALID))~~

~~- return FALSE;~~

~~- return TRUE;~~

~~-gint ignorance_rule_rulecheck(ignorance_rule *rule, const GString *text,~~

~~- gint flags) {~~

~~- if((flags & rule->flags) && rule->enabled){~~

~~- switch(rule->type){~~

~~- case IGNORANCE_RULE_SIMPLETEXT:~~

~~- return simple_text_rulecheck(rule,text);~~

~~-#ifdef HAVE_REGEX_H~~

~~- case IGNORANCE_RULE_REGEX:~~

~~- return regex_rulecheck(rule,text);~~

~~-#endif~~

~~- default:~~

~~- return 0;~~

~~- }~~

~~- return 0;~~

~~-gint simple_text_rulecheck(ignorance_rule *rule,const GString *text) {~~

~~- const gchar *rulevalue=(const gchar*)(rule->value);~~

~~- if(NULL!=g_strstr_len(text->str,text->len,rulevalue))~~

~~- return rule->score;~~

~~- return 0;~~

~~-#ifdef HAVE_REGEX_H~~

~~-gint regex_rulecheck(ignorance_rule *rule, const GString *text) {~~

~~- regex_t reg;~~

~~- gint rv=0;~~

~~- if(regcomp(&reg,(const gchar*)rule->value,REG_EXTENDED | REG_NOSUB))~~

~~- purple_debug_error("ignorance", "Error parsing regex %s\n",~~

~~- (const gchar*)(rule->value));~~

~~- else if(!regexec(&reg,text->str,1,NULL,0))~~

~~- rv=rule->score;~~

~~- regfree(&reg);~~

~~- return rv;~~

~~-#endif~~

~~-gint repeat_rulecheck(ignorance_rule *rule, gint repeats) {~~

~~- gint allowed_repeats = atoi((gchar*)(rule->value));~~

~~- gint score=0;~~

~~- if(repeats >= allowed_repeats)~~

~~- score=rule->score;~~

~~- return score;~~

~~-ignorance_rule* ignorance_rule_read_old(const gchar *ruletext) {~~

~~- gchar *tokptr=strchr((gchar*)ruletext,' '), **tokens=NULL;~~

~~- ignorance_rule *rule=ignorance_rule_new();~~

~~- int i=0;~~

~~- if(!tokptr){~~

~~- ignorance_rule_free(rule);~~

~~- return NULL;~~

~~- }~~

~~- tokens=g_strsplit(ruletext," ",INT_MAX);~~

~~- for(i=0;tokens[i];++i)~~

~~- assign_rule_token(rule,tokens[i]);~~

~~- if(rule->score > 9 || rule->score < -9)~~

~~- rule->score=IGNORANCE_FLAG_IGNORE;~~

~~- else~~

~~- rule->score=IGNORANCE_FLAG_FILTER;~~

~~- g_strfreev(tokens);~~

~~- return rule;~~

~~-ignorance_rule* ignorance_rule_read(const gchar *ruletext) {~~

~~- gchar*tokptr=strchr((gchar*)ruletext,'\n'), **tokens;~~

~~- ignorance_rule *rule=ignorance_rule_new();~~

~~- int i=0;~~

~~- if(!tokptr){~~

~~- ignorance_rule_free(rule);~~

~~- return ignorance_rule_read_old(ruletext);~~

~~- }~~

~~- tokens=g_strsplit(ruletext,"\n",INT_MAX);~~

~~- for(i=0;tokens[i];++i)~~

~~- assign_rule_token(rule,tokens[i]);~~

~~- g_strfreev(tokens);~~

~~- return rule;~~

-/*

~~- * Parses out a token of the form tokenname="value" and assigns it to a rulename~~

- *

~~- * rule is the rule to be updated~~

~~- * tokentxt is the token string~~

~~- * true returned if token is valid and successfully added to the rule~~

- *

~~- * level name1="value1" name2="value2" ...~~

~~- */~~

~~-gboolean assign_rule_token(ignorance_rule *rule,const gchar *tokentxt) {~~

~~- gchar *name=(gchar*)tokentxt, *value=NULL;~~

~~- gboolean rv=TRUE;~~

~~- gint cursor=0;~~

~~- value=strchr(tokentxt,'=');~~

~~- if(value) {~~

~~- (*value)='\0';~~

~~- ++value;~~

~~- if('"'==(*value)){~~

~~- ++value;~~

~~- cursor=strlen(value)-1;~~

~~- if('"'==value[cursor])~~

~~- value[cursor]='\0';~~

~~- }~~

~~- if(!strncasecmp(name,"name",BUFSIZ))~~

~~- g_string_assign(rule->name,value);~~

~~- else if(!strncasecmp(name,"type",BUFSIZ))~~

~~- rule->type=atoi(value);~~

~~- else if(!strncasecmp(name,"value",BUFSIZ)) {~~

~~- rule->value=(gchar*)g_malloc((strlen(value)+1)*sizeof(gchar));~~

~~- strncpy(rule->value,value,strlen(value)+1);~~

~~- }else if(!strncasecmp(name,"score",BUFSIZ))~~

~~- rule->score=atoi(value);~~

~~- else if(!strncasecmp(name,"flags",BUFSIZ))~~

~~- rule->flags=atoi(value);~~

~~- else if(!strncasecmp(name,"enabled",BUFSIZ))~~

~~- rule->enabled=(gboolean)atoi(value);~~

~~- else if(!strncasecmp(name,"message",BUFSIZ)) {~~

~~- rule->message=(gchar*)g_malloc((strlen(value)+1)*sizeof(gchar));~~

~~- strncpy(rule->message,value,strlen(value)+1);~~

~~- } else if(!strncasecmp(name,"command",BUFSIZ)) {~~

~~- rule->command=(gchar*)g_malloc((strlen(value)+1)*sizeof(gchar));~~

~~- strncpy(rule->command,value,strlen(value)+1);~~

~~- } else if(!strncasecmp(name,"sound",BUFSIZ)) {~~

~~- rule->sound=(gchar*)g_malloc((strlen(value)+1)*sizeof(gchar));~~

~~- strncpy(rule->sound,value,strlen(value)+1);~~

~~- } else~~

~~- rv=FALSE;~~

~~- } else~~

~~- rv=FALSE;~~

~~- return rv;~~

~~-gboolean ignorance_rule_write(ignorance_rule *rule,FILE *f){~~

~~- fprintf(f,"rule\nname=\"%s\"\ntype=\"%d\"\nscore=\"%d\"\nvalue=\"%s\"\nflags=\"%d\"\nenabled=\"%d\"\nmessage=\"%s\"\ncommand=\"%s\"\nsound=\"%s\"\n/rule\n",~~

~~- rule->name->str, rule->type, rule->score, (gchar*)(rule->value),~~

~~- rule->flags, rule->enabled, rule->message, rule->command, rule->sound);~~

~~- return TRUE;~~

~~--- a/ignorance/ignorance_rule.h Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,117 +0,0 @@

-/*

~~- * This program is free software; you can redistribute it and/or~~

~~- * modify it under the terms of the GNU General Public License~~

~~- * as published by the Free Software Foundation; either version 2~~

~~- * of the License, or (at your option) any later version.~~

- *

~~- * This program is distributed in the hope that it will be useful,~~

~~- * but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- * GNU General Public License for more details.~~

- *

~~- * You should have received a copy of the GNU General Public License~~

~~- * along with this program; if not, write to the Free Software~~

~~- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.~~

~~- */~~

~~-#ifndef IGNORANCE_RULE_H~~

~~-#define IGNORANCE_RULE_H~~

~~-#ifdef HAVE_CONFIG_H~~

~~-# include "../pp_config.h"~~

~~-#endif~~

~~-#include <stdlib.h>~~

~~-#include <sys/types.h>~~

~~-#include <glib.h>~~

~~-#include <glib/gprintf.h>~~

~~-#include "debug.h"~~

~~-#define IGNORANCE_RULE_INVALID 0~~

~~-#define IGNORANCE_RULE_MINVALID INT_MAX~~

~~-#define IGNORANCE_RULE_SIMPLETEXT 1~~

~~-#define IGNORANCE_RULE_SIMPLETEXT_NUMTOKENS 6~~

~~-#ifdef HAVE_REGEX_H~~

~~-#include <regex.h>~~

~~-#define IGNORANCE_RULE_REGEX 2~~

~~-#define IGNORANCE_RULE_REGEX_NUMTOKENS 6~~

~~-#endif~~

~~-#define IGNORANCE_RULE_REPEAT 4~~

~~-#define IGNORANCE_RULE_REPEAT_NUMTOKENS 6~~

~~-#define IGNORANCE_FLAG_FILTER 1~~

~~-#define IGNORANCE_FLAG_IGNORE 2~~

~~-#define IGNORANCE_FLAG_MESSAGE 4~~

~~-#define IGNORANCE_FLAG_EXECUTE 8~~

~~-#define IGNORANCE_FLAG_SOUND 16~~

-/*

~~- * describes an ignorance rule~~

- *

~~- * name - user's name for the rule~~

~~- * type - one of the ruletypes defined within this struct~~

- *

~~- * value - the actual value of the rule~~

~~- * could be a string/regex, integer, other~~

~~- * depending on the rule type~~

- *

~~- * score - an arbitrary (user-assigned) number~~

~~- * that determines the severity of the rule~~

~~- */~~

~~-typedef struct ignorance_rule {~~

~~- GString *name;~~

~~- gint type;~~

~~- gchar *value;~~

~~- gint score;~~

~~- gint flags;~~

~~- gboolean enabled;~~

~~- gchar *message,~~

~~- *command,~~

~~- *sound;~~

~~-} ignorance_rule;~~

~~-ignorance_rule* ignorance_rule_new();~~

~~-ignorance_rule* ignorance_rule_newp(const GString *name, gint type,~~

~~- const gchar *value, gint score, gint flags,~~

~~- gboolean enabled, const gchar *message,~~

~~- const gchar *sound, const gchar *command);~~

~~-void ignorance_rule_free(ignorance_rule *ir);~~

~~-void ignorance_rule_free_g(gpointer ir,gpointer user_data);~~

~~-gboolean ignorance_rule_has_type(gint type);~~

-/*

~~- * Determines whether a string violates a rule~~

- *

~~- * rule is the rule~~

~~- * text is the possibly offending string~~

~~- * returns 0/1 boolean~~

~~- */~~

~~-gint ignorance_rule_rulecheck(ignorance_rule *rule, const GString *text,~~

~~- gint flags);~~

~~-gint simple_text_rulecheck(ignorance_rule *rule, const GString *text);~~

~~-#ifdef HAVE_REGEX_H~~

~~-gint regex_rulecheck(ignorance_rule *rule, const GString *text);~~

~~-#endif~~

~~-gint repeat_rulecheck(ignorance_rule *rule, gint repeats);~~

~~-ignorance_rule* ignorance_rule_read(const gchar *ruletext);~~

-/*

~~- * Writes out an ignorance rule to a file~~

- *

~~- * rule is the rule to write~~

~~- * f is the file which will be written~~

~~- * success/failure returned~~

~~- */~~

~~-gboolean ignorance_rule_write(ignorance_rule *rule, FILE *f);~~

~~-#endif~~

~~--- a/ignorance/ignorance_violation.c Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,45 +0,0 @@

-/*

~~- * This program is free software; you can redistribute it and/or~~

~~- * modify it under the terms of the GNU General Public License~~

~~- * as published by the Free Software Foundation; either version 2~~

~~- * of the License, or (at your option) any later version.~~

- *

~~- * This program is distributed in the hope that it will be useful,~~

~~- * but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- * GNU General Public License for more details.~~

- *

~~- * You should have received a copy of the GNU General Public License~~

~~- * along with this program; if not, write to the Free Software~~

~~- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.~~

~~- */~~

~~-#include "ignorance_violation.h"~~

~~-#include "ignorance_internal.h"~~

~~-ignorance_violation* ignorance_violation_new() {~~

~~- return ignorance_violation_newp(IGNORANCE_FLAG_MESSAGE,"");~~

~~-ignorance_violation* ignorance_violation_newp(gint newtype,~~

~~- const gchar *newvalue){~~

~~- ignorance_violation *iv=(ignorance_violation*)g_malloc(sizeof(ignorance_violation));~~

~~- if(iv){~~

~~- iv->type=newtype;~~

~~- iv->value=g_strdup(newvalue);~~

~~- }~~

~~- return iv;~~

~~-void ignorance_violation_free(ignorance_violation *iv) {~~

~~- if(iv){~~

~~- g_free(iv->value);~~

~~- g_free(iv);~~

~~- }~~

~~-void ignorance_violation_free_g(gpointer iv, gpointer user_data) {~~

~~- ignorance_violation_free((ignorance_violation*)iv);~~

~~--- a/ignorance/ignorance_violation.h Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,32 +0,0 @@

-/*

~~- * This program is free software; you can redistribute it and/or~~

~~- * modify it under the terms of the GNU General Public License~~

~~- * as published by the Free Software Foundation; either version 2~~

~~- * of the License, or (at your option) any later version.~~

- *

~~- * This program is distributed in the hope that it will be useful,~~

~~- * but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- * GNU General Public License for more details.~~

- *

~~- * You should have received a copy of the GNU General Public License~~

~~- * along with this program; if not, write to the Free Software~~

~~- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.~~

~~- */~~

~~-#ifndef IGNORANCE_VIOLATION_H~~

~~-#define IGNORANCE_VIOLATION_H~~

~~-#include "ignorance.h"~~

~~-typedef struct ignorance_violation {~~

~~- gint type;~~

~~- gchar *value;~~

~~-} ignorance_violation;~~

~~-ignorance_violation* ignorance_violation_new();~~

~~-ignorance_violation* ignorance_violation_newp(gint newtype, const gchar *newvalue);~~

~~-void ignorance_violation_free(ignorance_violation *iv);~~

~~-void ignorance_violation_free_g(gpointer iv, gpointer user_data);~~

~~-#endif~~

~~--- a/ignorance/interface.c Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,284 +0,0 @@

-/*

~~- * This program is free software; you can redistribute it and/or~~

~~- * modify it under the terms of the GNU General Public License~~

~~- * as published by the Free Software Foundation; either version 2~~

~~- * of the License, or (at your option) any later version.~~

- *

~~- * This program is distributed in the hope that it will be useful,~~

~~- * but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- * GNU General Public License for more details.~~

- *

~~- * You should have received a copy of the GNU General Public License~~

~~- * along with this program; if not, write to the Free Software~~

~~- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.~~

~~- */~~

~~-#include <sys/types.h>~~

~~-#include <sys/stat.h>~~

~~-#include <unistd.h>~~

~~-#include <string.h>~~

~~-#include <stdio.h>~~

~~-#include <gdk/gdkkeysyms.h>~~

~~-#include <gtk/gtk.h>~~

~~-#include <gtkutils.h>~~

~~-#include "callbacks.h"~~

~~-#include "interface.h"~~

~~-#include "support.h"~~

~~-#include "ignorance.h"~~

~~-#include "ignorance_internal.h"~~

~~-GtkWidget* create_uiinfo (GPtrArray *levels) {~~

~~- GtkWidget *frame, *table, *hbox, *label;~~

~~- GtkWidget *scrolledwindow, *levelView, *button;~~

~~- rule_selected=TRUE;~~

~~- vbox1=gtk_vbox_new(FALSE, 0);~~

~~- gtk_widget_show(vbox1);~~

~~- vbox2 = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);~~

~~- gtk_widget_show(vbox2);~~

~~- gtk_box_pack_start(GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0);~~

~~- scrolledwindow=gtk_scrolled_window_new (NULL, NULL);~~

~~- gtk_widget_show(scrolledwindow);~~

~~- gtk_box_pack_start(GTK_BOX (vbox2), scrolledwindow, TRUE, TRUE, 0);~~

~~- gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolledwindow),~~

~~- GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);~~

~~- gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolledwindow),~~

~~- GTK_SHADOW_IN);~~

~~- store=gtk_tree_store_new(NUM_COLUMNS,G_TYPE_STRING,G_TYPE_STRING);~~

~~- levelView=gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));~~

~~- renderer=gtk_cell_renderer_text_new ();~~

~~- column=gtk_tree_view_column_new_with_attributes ("Levels", renderer,~~

~~- "text", LEVEL_COLUMN, NULL);~~

~~- gtk_tree_view_append_column(GTK_TREE_VIEW (levelView), column);~~

~~- column=gtk_tree_view_column_new_with_attributes("Rules", renderer, "text",~~

~~- RULE_COLUMN,NULL);~~

~~- gtk_tree_view_append_column (GTK_TREE_VIEW (levelView), column);~~

~~- load_form_with_levels(GTK_TREE_VIEW(levelView), levels);~~

~~- gtk_widget_show(levelView);~~

~~- gtk_container_add(GTK_CONTAINER(scrolledwindow), levelView);~~

~~- sel=gtk_tree_view_get_selection(GTK_TREE_VIEW(levelView));~~

~~- gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);~~

~~- hbox = gtk_hbox_new (FALSE, 0);~~

~~- gtk_widget_show (hbox);~~

~~- gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);~~

~~- button=pidgin_pixbuf_button_from_stock(_("Create new rule"),~~

~~- GTK_STOCK_ADD, PIDGIN_BUTTON_HORIZONTAL);~~

~~- gtk_widget_show (button);~~

~~- gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);~~

~~- g_signal_connect((gpointer) button, "clicked",~~

~~- G_CALLBACK (on_levelAdd_clicked), levelView);~~

~~- button=pidgin_pixbuf_button_from_stock(_("Create new group"),~~

~~- GTK_STOCK_ADD, PIDGIN_BUTTON_HORIZONTAL);~~

~~- gtk_widget_show (button);~~

~~- gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);~~

~~- g_signal_connect ((gpointer) button, "clicked",~~

~~- G_CALLBACK (on_groupAdd_clicked), levelView);~~

~~- button=pidgin_pixbuf_button_from_stock(_("Save changes"), GTK_STOCK_YES,~~

~~- PIDGIN_BUTTON_HORIZONTAL);~~

~~- gtk_widget_show (button);~~

~~- gtk_box_pack_start(GTK_BOX (hbox), button, TRUE, TRUE, 0);~~

~~- g_signal_connect((gpointer) button, "clicked",~~

~~- G_CALLBACK (on_levelEdit_clicked), levelView);~~

~~-/* XXX: The stock-icon for levelDel doesn't show, because the text is~~

~~- * set from callback.c. Can we do with just `Remove' for the text~~

~~- * and not updating as the selection in the tree changes?~~

~~- */~~

~~- levelDel=pidgin_pixbuf_button_from_stock(_("Remove rule"), GTK_STOCK_REMOVE,~~

~~- PIDGIN_BUTTON_HORIZONTAL);~~

~~- gtk_widget_show (levelDel);~~

~~- gtk_box_pack_start (GTK_BOX (hbox), levelDel, TRUE, TRUE, 0);~~

~~- g_signal_connect((gpointer) levelDel, "clicked",~~

~~- G_CALLBACK (on_levelDel_clicked), levelView);~~

~~- table=gtk_table_new(3, 2, FALSE);~~

~~- gtk_container_set_border_width(GTK_CONTAINER(table), PIDGIN_HIG_BOX_SPACE);~~

~~- gtk_table_set_col_spacings(GTK_TABLE(table), PIDGIN_HIG_BOX_SPACE);~~

~~- gtk_table_set_row_spacings(GTK_TABLE(table), PIDGIN_HIG_BOX_SPACE);~~

~~- gtk_widget_show (table);~~

~~- gtk_box_pack_start (GTK_BOX (vbox2), table, FALSE, TRUE, 0);~~

~~- label=gtk_label_new_with_mnemonic(_("Name: "));~~

~~- gtk_widget_show(label);~~

~~- gtk_table_attach(GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, 0, 0, 0);~~

~~- rulename=gtk_entry_new ();~~

~~- gtk_widget_show(rulename);~~

~~- gtk_table_attach_defaults(GTK_TABLE (table), rulename, 1, 2, 0, 1);~~

~~- label=gtk_label_new_with_mnemonic(_("Filter: "));~~

~~- gtk_widget_show(label);~~

~~- gtk_table_attach(GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, 0, 0, 0);~~

~~- filtervalue=gtk_entry_new ();~~

~~- gtk_widget_show(filtervalue);~~

~~- gtk_table_attach_defaults(GTK_TABLE (table), filtervalue, 1, 2, 1, 2);~~

~~- hbox=gtk_hbox_new (FALSE, 0);~~

~~- gtk_widget_show(hbox);~~

~~- gtk_table_attach_defaults(GTK_TABLE (table), hbox, 0, 2, 2, 3);~~

~~- enabled_cb=gtk_check_button_new_with_mnemonic(_("Enabled"));~~

~~- gtk_widget_show(enabled_cb);~~

~~- gtk_box_pack_start(GTK_BOX(hbox),enabled_cb,FALSE,FALSE,0);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enabled_cb),TRUE);~~

~~-#ifdef HAVE_REGEX_H~~

~~- regex_cb=gtk_check_button_new_with_mnemonic (_("Regular Expression"));~~

~~- gtk_widget_show(regex_cb);~~

~~- gtk_box_pack_start (GTK_BOX (hbox), regex_cb, FALSE, FALSE, 0);~~

~~-#endif~~

~~- repeat_cb=gtk_check_button_new_with_mnemonic (_("Repeat"));~~

~~- gtk_widget_set_sensitive(repeat_cb,FALSE);~~

~~- gtk_widget_show(repeat_cb);~~

~~- gtk_box_pack_start(GTK_BOX (hbox), repeat_cb, FALSE, FALSE, 0);~~

~~- gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (repeat_cb), FALSE);~~

~~- frame=gtk_frame_new (NULL);~~

~~- gtk_widget_show(frame);~~

~~- gtk_box_pack_start(GTK_BOX (vbox2), frame, FALSE, TRUE, 0);~~

~~- table=gtk_table_new(4, 2, FALSE);~~

~~- gtk_container_set_border_width(GTK_CONTAINER(table), PIDGIN_HIG_BOX_SPACE);~~

~~- gtk_table_set_col_spacings(GTK_TABLE(table), PIDGIN_HIG_BOX_SPACE);~~

~~- gtk_widget_show(table);~~

~~- gtk_container_add(GTK_CONTAINER(frame), table);~~

~~- hbox=gtk_hbox_new(FALSE, 0);~~

~~- gtk_widget_show(hbox);~~

~~- gtk_table_attach_defaults(GTK_TABLE(table), hbox, 0, 2, 0, 1);~~

~~- filter_cb=gtk_check_button_new_with_label(_("Filter"));~~

~~- gtk_widget_show(filter_cb);~~

~~- gtk_box_pack_start(GTK_BOX (hbox), filter_cb, FALSE, FALSE, 0);~~

~~- ignore_cb=gtk_check_button_new_with_label(_("Ignore"));~~

~~- gtk_widget_show(ignore_cb);~~

~~- gtk_box_pack_start(GTK_BOX (hbox), ignore_cb, FALSE, FALSE, 0);~~

~~- message_cb = gtk_check_button_new_with_label(_("Send Message"));~~

~~- gtk_widget_show(message_cb);~~

~~- gtk_table_attach(GTK_TABLE(table), message_cb, 0, 1, 1, 2, GTK_FILL, 0, 0, 0);~~

~~- message_entry=gtk_entry_new();~~

~~- gtk_widget_set_sensitive(message_entry,FALSE);~~

~~- gtk_widget_show(message_entry);~~

~~- gtk_table_attach_defaults(GTK_TABLE(table), message_entry, 1, 2, 1, 2);~~

~~- sound_cb = gtk_check_button_new_with_label(_("Play sound"));~~

~~- gtk_widget_show(sound_cb);~~

~~- gtk_table_attach(GTK_TABLE(table), sound_cb, 0, 1, 2, 3, GTK_FILL, 0, 0, 0);~~

~~- hbox=gtk_hbox_new (FALSE, 0);~~

~~- gtk_widget_show (hbox);~~

~~- gtk_table_attach_defaults(GTK_TABLE(table), hbox, 1, 2, 2, 3);~~

~~- sound_entry=gtk_entry_new();~~

~~- gtk_widget_set_sensitive(sound_entry,FALSE);~~

~~- gtk_widget_show(sound_entry);~~

~~- gtk_box_pack_start(GTK_BOX(hbox),sound_entry,FALSE,FALSE,0);~~

~~- sound_browse=gtk_button_new_with_label(_("Browse"));~~

~~- gtk_widget_set_sensitive(sound_browse,FALSE);~~

~~- gtk_widget_show(sound_browse);~~

~~- gtk_box_pack_start(GTK_BOX(hbox),sound_browse,FALSE,FALSE,0);~~

~~- execute_cb=gtk_check_button_new_with_label(_("Execute command"));~~

~~- gtk_widget_show(execute_cb);~~

~~- gtk_table_attach(GTK_TABLE(table), execute_cb, 0, 1, 3, 4, GTK_FILL, 0, 0, 0);~~

~~- execute_entry=gtk_entry_new();~~

~~- gtk_widget_set_sensitive(execute_entry,FALSE);~~

~~- gtk_widget_show(execute_entry);~~

~~- gtk_table_attach_defaults(GTK_TABLE(table), execute_entry, 1, 2, 3, 4);~~

~~- label=gtk_label_new(_("Take action"));~~

~~- gtk_widget_show(label);~~

~~- gtk_frame_set_label_widget(GTK_FRAME (frame), label);~~

~~- frame=gtk_frame_new (NULL);~~

~~- gtk_widget_show(frame);~~

~~- gtk_box_pack_start(GTK_BOX (vbox2), frame, FALSE, TRUE, 0);~~

~~- table=gtk_table_new (3, 2, FALSE);~~

~~- gtk_widget_show(table);~~

~~- gtk_container_set_border_width(GTK_CONTAINER(table), PIDGIN_HIG_BOX_SPACE);~~

~~- gtk_table_set_col_spacings(GTK_TABLE(table), PIDGIN_HIG_BOX_SPACE);~~

~~- gtk_container_add(GTK_CONTAINER (frame), table);~~

~~- im_type_cb=gtk_check_button_new_with_mnemonic(_("IM Text"));~~

~~- gtk_widget_show(im_type_cb);~~

~~- gtk_table_attach(GTK_TABLE (table), im_type_cb, 0, 1, 0, 1,~~

~~- (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),~~

~~- (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);~~

~~- chat_type_cb=gtk_check_button_new_with_mnemonic(_("Chat Text"));~~

~~- gtk_widget_show(chat_type_cb);~~

~~- gtk_table_attach(GTK_TABLE (table), chat_type_cb, 1, 2, 0, 1,~~

~~- (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),~~

~~- (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);~~

~~- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (chat_type_cb), TRUE);~~

~~- username_type_cb=gtk_check_button_new_with_mnemonic(_("User names"));~~

~~- gtk_widget_show(username_type_cb);~~

~~- gtk_table_attach(GTK_TABLE (table), username_type_cb, 0, 1, 1, 2,~~

~~- (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),~~

~~- (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);~~

~~- enterleave_type_cb=gtk_check_button_new_with_mnemonic (_("Enter/Leave"));~~

~~- gtk_widget_show(enterleave_type_cb);~~

~~- gtk_table_attach(GTK_TABLE (table), enterleave_type_cb, 1, 2, 1, 2,~~

~~- (GtkAttachOptions) (GTK_FILL),~~

~~- (GtkAttachOptions) (0), 0, 0);~~

~~- invite_type_cb=gtk_check_button_new_with_mnemonic (_("Invitations"));~~

~~- gtk_widget_show(invite_type_cb);~~

~~- gtk_table_attach(GTK_TABLE (table), invite_type_cb, 0, 1, 2, 3,~~

~~- (GtkAttachOptions) (GTK_FILL),~~

~~- (GtkAttachOptions) (0), 0, 0);~~

~~- label=gtk_label_new (_("Filter"));~~

~~- gtk_widget_show(label);~~

~~- gtk_frame_set_label_widget(GTK_FRAME (frame), label);~~

~~- g_signal_connect(GTK_WIDGET(vbox1), "destroy", G_CALLBACK(save_conf),NULL);~~

~~- g_signal_connect((gpointer)sel, "changed",~~

~~- G_CALLBACK (on_levelView_row_activated), NULL);~~

~~- g_signal_connect((gpointer) filter_cb, "toggled",~~

~~- G_CALLBACK (on_filter_cb_toggled), NULL);~~

~~- g_signal_connect((gpointer) ignore_cb, "toggled",~~

~~- G_CALLBACK (on_ignore_cb_toggled), NULL);~~

~~- g_signal_connect((gpointer) message_cb, "toggled",~~

~~- G_CALLBACK (on_message_cb_toggled), NULL);~~

~~- g_signal_connect((gpointer) sound_cb, "toggled",~~

~~- G_CALLBACK (on_sound_cb_toggled), NULL);~~

~~- g_signal_connect((gpointer) execute_cb, "toggled",~~

~~- G_CALLBACK (on_execute_cb_toggled), NULL);~~

~~- g_signal_connect((gpointer) sound_browse, "clicked",~~

~~- G_CALLBACK (on_sound_browse_clicked), NULL);~~

~~- return vbox1;~~

~~--- a/ignorance/interface.h Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,48 +0,0 @@

-/*

~~- * This program is free software; you can redistribute it and/or~~

~~- * modify it under the terms of the GNU General Public License~~

~~- * as published by the Free Software Foundation; either version 2~~

~~- * of the License, or (at your option) any later version.~~

- *

~~- * This program is distributed in the hope that it will be useful,~~

~~- * but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- * GNU General Public License for more details.~~

- *

~~- * You should have received a copy of the GNU General Public License~~

~~- * along with this program; if not, write to the Free Software~~

~~- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.~~

~~- */~~

~~-#ifndef IGNORANCE_INTERFACE_H~~

~~-#define IGNORANCE_INTERFACE_H~~

~~-GtkWidget *vbox1;~~

~~-GtkWidget *vbox2;~~

~~-GtkWidget *levelDel;~~

~~-GtkWidget *rulename;~~

~~-GtkWidget *filtervalue;~~

~~-GtkWidget *repeat_cb;~~

~~-GtkWidget *regex_cb;~~

~~-GtkWidget *im_type_cb;~~

~~-GtkWidget *chat_type_cb;~~

~~-GtkWidget *username_type_cb;~~

~~-GtkWidget *enterleave_type_cb;~~

~~-GtkWidget *invite_type_cb;~~

~~-GtkWidget *enabled_cb;~~

~~-GtkWidget *filter_cb;~~

~~-GtkWidget *ignore_cb;~~

~~-GtkWidget *message_cb, *message_entry;~~

~~-GtkWidget *sound_cb, *sound_entry, *sound_browse;~~

~~-GtkWidget *execute_cb, *execute_entry, *execute_browse;~~

~~-GtkCellRenderer *renderer;~~

~~-GtkTreeViewColumn *column;~~

~~-GtkTreeStore *store;~~

~~-GtkTreeSelection *sel;~~

~~-gboolean rule_selected;~~

~~-GtkWidget* create_uiinfo(GPtrArray *levels);~~

~~-#endif~~

~~--- a/ignorance/meson.build Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,26 +0,0 @@

~~-if TYPES.contains('incomplete') and PIDGIN.found()~~

~~- ignorance_confdir = join_paths(~~

~~- get_option('prefix'),~~

~~- get_option('sysconfdir'),~~

~~- 'pidgin')~~

~~- install_data('ignorance.conf', install_dir : ignorance_confdir)~~

~~- ignorance = shared_module('ignorance',~~

~~- 'ignorance.c',~~

~~- 'ignorance_level.c',~~

~~- 'ignorance_rule.c',~~

~~- 'ignorance_violation.c',~~

~~- 'ignorance_denizen.c',~~

~~- 'callbacks.c',~~

~~- 'interface.c',~~

~~- 'support.c',~~

~~- c_args : [~~

~~- '-DIGNORANCE_CONFDIR="@0@"'.format(ignorance_confdir),~~

~~- ],~~

~~- dependencies : [PIDGIN, GTK],~~

~~- name_prefix : '',~~

~~- install : true,~~

~~- install_dir : PIDGIN_LIBDIR)~~

~~- PP_PIDGIN_BUILD += 'ignorance'~~

~~-endif~~

~~--- a/ignorance/regex.c Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,4952 +0,0 @@

~~-/* Extended regular expression matching and search library,~~

~~- version 0.12.~~

~~- (Implements POSIX draft P10003.2/D11.2, except for~~

~~- internationalization features.)~~

~~- This program is free software; you can redistribute it and/or modify~~

~~- it under the terms of the GNU General Public License as published by~~

~~- the Free Software Foundation; either version 2, or (at your option)~~

~~- any later version.~~

~~- This program is distributed in the hope that it will be useful,~~

~~- but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- GNU General Public License for more details.~~

~~- You should have received a copy of the GNU General Public License~~

~~- along with this program; if not, write to the Free Software~~

~~- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */~~

~~-/* AIX requires this to be the first thing in the file. */~~

~~-#if defined (_AIX) && !defined (REGEX_MALLOC)~~

~~- #pragma alloca~~

~~-#endif~~

~~-#define _GNU_SOURCE~~

~~-/* We need this for `regex.h', and perhaps for the Emacs include files. */~~

~~-#include <sys/types.h>~~

~~-#ifdef HAVE_CONFIG_H~~

~~-#include "../ig_config.h"~~

~~-#endif~~

~~-/* The `emacs' switch turns on certain matching commands~~

~~- that make sense only in Emacs. */~~

~~-#ifdef emacs~~

~~-#include "lisp.h"~~

~~-#include "buffer.h"~~

~~-#include "syntax.h"~~

~~-/* Emacs uses `NULL' as a predicate. */~~

~~-#undef NULL~~

~~-#else /* not emacs */~~

~~-/* We used to test for `BSTRING' here, but only GCC and Emacs define~~

~~- `BSTRING', as far as I know, and neither of them use this code. */~~

~~-#if HAVE_STRING_H || STDC_HEADERS~~

~~-#include <string.h>~~

~~-#ifndef bcmp~~

~~-#define bcmp(s1, s2, n) memcmp ((s1), (s2), (n))~~

~~-#endif~~

~~-#ifndef bcopy~~

~~-#define bcopy(s, d, n) memcpy ((d), (s), (n))~~

~~-#endif~~

~~-#ifndef bzero~~

~~-#define bzero(s, n) memset ((s), 0, (n))~~

~~-#endif~~

~~-#else~~

~~-#include <strings.h>~~

~~-#endif~~

~~-#ifdef STDC_HEADERS~~

~~-#include <stdlib.h>~~

~~-#else~~

~~-char *malloc ();~~

~~-char *realloc ();~~

~~-#endif~~

~~-/* Define the syntax stuff for \<, \>, etc. */~~

~~-/* This must be nonzero for the wordchar and notwordchar pattern~~

~~- commands in re_match_2. */~~

~~-#ifndef Sword~~

~~-#define Sword 1~~

~~-#endif~~

~~-#ifdef SYNTAX_TABLE~~

~~-extern char *re_syntax_table;~~

~~-#else /* not SYNTAX_TABLE */~~

~~-/* How many characters in the character set. */~~

~~-#define CHAR_SET_SIZE 256~~

~~-static char re_syntax_table[CHAR_SET_SIZE];~~

~~-static void~~

~~-init_syntax_once ()~~

~~- register int c;~~

~~- static int done = 0;~~

~~- if (done)~~

~~- return;~~

~~- bzero (re_syntax_table, sizeof re_syntax_table);~~

~~- for (c = 'a'; c <= 'z'; c++)~~

~~- re_syntax_table[c] = Sword;~~

~~- for (c = 'A'; c <= 'Z'; c++)~~

~~- re_syntax_table[c] = Sword;~~

~~- for (c = '0'; c <= '9'; c++)~~

~~- re_syntax_table[c] = Sword;~~

~~- re_syntax_table['_'] = Sword;~~

~~- done = 1;~~

~~-#endif /* not SYNTAX_TABLE */~~

~~-#define SYNTAX(c) re_syntax_table[c]~~

~~-#endif /* not emacs */~~

~~-/* Get the interface, including the syntax bits. */~~

~~-#include "regex.h"~~

~~-/* isalpha etc. are used for the character classes. */~~

~~-#include <ctype.h>~~

~~-#ifndef isascii~~

~~-#define isascii(c) 1~~

~~-#endif~~

~~-#ifdef isblank~~

~~-#define ISBLANK(c) (isascii (c) && isblank (c))~~

~~-#else~~

~~-#define ISBLANK(c) ((c) == ' ' || (c) == '\t')~~

~~-#endif~~

~~-#ifdef isgraph~~

~~-#define ISGRAPH(c) (isascii (c) && isgraph (c))~~

~~-#else~~

~~-#define ISGRAPH(c) (isascii (c) && isprint (c) && !isspace (c))~~

~~-#endif~~

~~-#define ISPRINT(c) (isascii (c) && isprint (c))~~

~~-#define ISDIGIT(c) (isascii (c) && isdigit (c))~~

~~-#define ISALNUM(c) (isascii (c) && isalnum (c))~~

~~-#define ISALPHA(c) (isascii (c) && isalpha (c))~~

~~-#define ISCNTRL(c) (isascii (c) && iscntrl (c))~~

~~-#define ISLOWER(c) (isascii (c) && islower (c))~~

~~-#define ISPUNCT(c) (isascii (c) && ispunct (c))~~

~~-#define ISSPACE(c) (isascii (c) && isspace (c))~~

~~-#define ISUPPER(c) (isascii (c) && isupper (c))~~

~~-#define ISXDIGIT(c) (isascii (c) && isxdigit (c))~~

~~-#ifndef NULL~~

~~-#define NULL 0~~

~~-#endif~~

~~-/* We remove any previous definition of `SIGN_EXTEND_CHAR',~~

~~- since ours (we hope) works properly with all combinations of~~

~~- machines, compilers, `char' and `unsigned char' argument types.~~

~~- (Per Bothner suggested the basic approach.) */~~

~~-#undef SIGN_EXTEND_CHAR~~

~~-#if __STDC__~~

~~-#define SIGN_EXTEND_CHAR(c) ((signed char) (c))~~

~~-#else /* not __STDC__ */~~

~~-/* As in Harbison and Steele. */~~

~~-#define SIGN_EXTEND_CHAR(c) ((((unsigned char) (c)) ^ 128) - 128)~~

~~-#endif~~

~~-/* Should we use malloc or alloca? If REGEX_MALLOC is not defined, we~~

~~- use `alloca' instead of `malloc'. This is because using malloc in~~

~~- re_search* or re_match* could cause memory leaks when C-g is used in~~

~~- Emacs; also, malloc is slower and causes storage fragmentation. On~~

~~- the other hand, malloc is more portable, and easier to debug.~~

~~- Because we sometimes use alloca, some routines have to be macros,~~

~~- not functions -- `alloca'-allocated space disappears at the end of the~~

~~- function it is called in. */~~

~~-#ifdef REGEX_MALLOC~~

~~-#define REGEX_ALLOCATE malloc~~

~~-#define REGEX_REALLOCATE(source, osize, nsize) realloc (source, nsize)~~

~~-#else /* not REGEX_MALLOC */~~

~~-/* Emacs already defines alloca, sometimes. */~~

~~-#ifndef alloca~~

~~-/* Make alloca work the best possible way. */~~

~~-#ifdef __GNUC__~~

~~-#define alloca __builtin_alloca~~

~~-#else /* not __GNUC__ */~~

~~-#if HAVE_ALLOCA_H~~

~~-#include <alloca.h>~~

~~-#else /* not __GNUC__ or HAVE_ALLOCA_H */~~

~~-#ifndef _AIX /* Already did AIX, up at the top. */~~

~~-char *alloca ();~~

~~-#endif /* not _AIX */~~

~~-#endif /* not HAVE_ALLOCA_H */~~

~~-#endif /* not __GNUC__ */~~

~~-#endif /* not alloca */~~

~~-#define REGEX_ALLOCATE alloca~~

~~-/* Assumes a `char *destination' variable. */~~

~~-#define REGEX_REALLOCATE(source, osize, nsize) \~~

~~- (destination = (char *) alloca (nsize), \~~

~~- bcopy (source, destination, osize), \~~

~~- destination)~~

~~-#endif /* not REGEX_MALLOC */~~

~~-/* True if `size1' is non-NULL and PTR is pointing anywhere inside~~

~~- `string1' or just past its end. This works if PTR is NULL, which is~~

~~- a good thing. */~~

~~-#define FIRST_STRING_P(ptr) \~~

~~- (size1 && string1 <= (ptr) && (ptr) <= string1 + size1)~~

~~-/* (Re)Allocate N items of type T using malloc, or fail. */~~

~~-#define TALLOC(n, t) ((t *) malloc ((n) * sizeof (t)))~~

~~-#define RETALLOC(addr, n, t) ((addr) = (t *) realloc (addr, (n) * sizeof (t)))~~

~~-#define REGEX_TALLOC(n, t) ((t *) REGEX_ALLOCATE ((n) * sizeof (t)))~~

~~-#define BYTEWIDTH 8 /* In bits. */~~

~~-#define STREQ(s1, s2) ((strcmp (s1, s2) == 0))~~

~~-#define MAX(a, b) ((a) > (b) ? (a) : (b))~~

~~-#define MIN(a, b) ((a) < (b) ? (a) : (b))~~

~~-typedef char boolean;~~

~~-#define false 0~~

~~-#define true 1~~

~~-/* These are the command codes that appear in compiled regular~~

~~- expressions. Some opcodes are followed by argument bytes. A~~

~~- command code can specify any interpretation whatsoever for its~~

~~- arguments. Zero bytes may appear in the compiled regular expression.~~

~~- The value of `exactn' is needed in search.c (search_buffer) in Emacs.~~

~~- So regex.h defines a symbol `RE_EXACTN_VALUE' to be 1; the value of~~

~~- `exactn' we use here must also be 1. */~~

~~-typedef enum~~

~~- no_op = 0,~~

~~- /* Followed by one byte giving n, then by n literal bytes. */~~

~~- exactn = 1,~~

~~- /* Matches any (more or less) character. */~~

~~- anychar,~~

~~- /* Matches any one char belonging to specified set. First~~

~~- following byte is number of bitmap bytes. Then come bytes~~

~~- for a bitmap saying which chars are in. Bits in each byte~~

~~- are ordered low-bit-first. A character is in the set if its~~

~~- bit is 1. A character too large to have a bit in the map is~~

~~- automatically not in the set. */~~

~~- charset,~~

~~- /* Same parameters as charset, but match any character that is~~

~~- not one of those specified. */~~

~~- charset_not,~~

~~- /* Start remembering the text that is matched, for storing in a~~

~~- register. Followed by one byte with the register number, in~~

~~- the range 0 to one less than the pattern buffer's re_nsub~~

~~- field. Then followed by one byte with the number of groups~~

~~- inner to this one. (This last has to be part of the~~

~~- start_memory only because we need it in the on_failure_jump~~

~~- of re_match_2.) */~~

~~- start_memory,~~

~~- /* Stop remembering the text that is matched and store it in a~~

~~- memory register. Followed by one byte with the register~~

~~- number, in the range 0 to one less than `re_nsub' in the~~

~~- pattern buffer, and one byte with the number of inner groups,~~

~~- just like `start_memory'. (We need the number of inner~~

~~- groups here because we don't have any easy way of finding the~~

~~- corresponding start_memory when we're at a stop_memory.) */~~

~~- stop_memory,~~

~~- /* Match a duplicate of something remembered. Followed by one~~

~~- byte containing the register number. */~~

~~- duplicate,~~

~~- /* Fail unless at beginning of line. */~~

~~- begline,~~

~~- /* Fail unless at end of line. */~~

~~- endline,~~

~~- /* Succeeds if at beginning of buffer (if emacs) or at beginning~~

~~- of string to be matched (if not). */~~

~~- begbuf,~~

~~- /* Analogously, for end of buffer/string. */~~

~~- endbuf,~~

~~- /* Followed by two byte relative address to which to jump. */~~

~~- jump,~~

~~- /* Same as jump, but marks the end of an alternative. */~~

~~- jump_past_alt,~~

~~- /* Followed by two-byte relative address of place to resume at~~

~~- in case of failure. */~~

~~- on_failure_jump,~~

~~- /* Like on_failure_jump, but pushes a placeholder instead of the~~

~~- current string position when executed. */~~

~~- on_failure_keep_string_jump,~~

~~- /* Throw away latest failure point and then jump to following~~

~~- two-byte relative address. */~~

~~- pop_failure_jump,~~

~~- /* Change to pop_failure_jump if know won't have to backtrack to~~

~~- match; otherwise change to jump. This is used to jump~~

~~- back to the beginning of a repeat. If what follows this jump~~

~~- clearly won't match what the repeat does, such that we can be~~

~~- sure that there is no use backtracking out of repetitions~~

~~- already matched, then we change it to a pop_failure_jump.~~

~~- Followed by two-byte address. */~~

~~- maybe_pop_jump,~~

~~- /* Jump to following two-byte address, and push a dummy failure~~

~~- point. This failure point will be thrown away if an attempt~~

~~- is made to use it for a failure. A `+' construct makes this~~

~~- before the first repeat. Also used as an intermediary kind~~

~~- of jump when compiling an alternative. */~~

~~- dummy_failure_jump,~~

~~- /* Push a dummy failure point and continue. Used at the end of~~

~~- alternatives. */~~

~~- push_dummy_failure,~~

~~- /* Followed by two-byte relative address and two-byte number n.~~

~~- After matching N times, jump to the address upon failure. */~~

~~- succeed_n,~~

~~- /* Followed by two-byte relative address, and two-byte number n.~~

~~- Jump to the address N times, then fail. */~~

~~- jump_n,~~

~~- /* Set the following two-byte relative address to the~~

~~- subsequent two-byte number. The address *includes* the two~~

~~- bytes of number. */~~

~~- set_number_at,~~

~~- wordchar, /* Matches any word-constituent character. */~~

~~- notwordchar, /* Matches any char that is not a word-constituent. */~~

~~- wordbeg, /* Succeeds if at word beginning. */~~

~~- wordend, /* Succeeds if at word end. */~~

~~- wordbound, /* Succeeds if at a word boundary. */~~

~~- notwordbound /* Succeeds if not at a word boundary. */~~

~~-#ifdef emacs~~

~~- ,before_dot, /* Succeeds if before point. */~~

~~- at_dot, /* Succeeds if at point. */~~

~~- after_dot, /* Succeeds if after point. */~~

~~- /* Matches any character whose syntax is specified. Followed by~~

~~- a byte which contains a syntax code, e.g., Sword. */~~

~~- syntaxspec,~~

~~- /* Matches any character whose syntax is not that specified. */~~

~~- notsyntaxspec~~

~~-#endif /* emacs */~~

~~-} re_opcode_t;~~

~~-/* Common operations on the compiled pattern. */~~

~~-/* Store NUMBER in two contiguous bytes starting at DESTINATION. */~~

~~-#define STORE_NUMBER(destination, number) \~~

~~- do { \~~

~~- (destination)[0] = (number) & 0377; \~~

~~- (destination)[1] = (number) >> 8; \~~

~~- } while (0)~~

~~-/* Same as STORE_NUMBER, except increment DESTINATION to~~

~~- the byte after where the number is stored. Therefore, DESTINATION~~

~~- must be an lvalue. */~~

~~-#define STORE_NUMBER_AND_INCR(destination, number) \~~

~~- do { \~~

~~- STORE_NUMBER (destination, number); \~~

~~- (destination) += 2; \~~

~~- } while (0)~~

~~-/* Put into DESTINATION a number stored in two contiguous bytes starting~~

~~- at SOURCE. */~~

~~-#define EXTRACT_NUMBER(destination, source) \~~

~~- do { \~~

~~- (destination) = *(source) & 0377; \~~

~~- (destination) += SIGN_EXTEND_CHAR (*((source) + 1)) << 8; \~~

~~- } while (0)~~

~~-#ifdef DEBUG~~

~~-static void~~

~~-extract_number (dest, source)~~

~~- int *dest;~~

~~- unsigned char *source;~~

~~- int temp = SIGN_EXTEND_CHAR (*(source + 1));~~

~~- *dest = *source & 0377;~~

~~- *dest += temp << 8;~~

~~-#ifndef EXTRACT_MACROS /* To debug the macros. */~~

~~-#undef EXTRACT_NUMBER~~

~~-#define EXTRACT_NUMBER(dest, src) extract_number (&dest, src)~~

~~-#endif /* not EXTRACT_MACROS */~~

~~-#endif /* DEBUG */~~

~~-/* Same as EXTRACT_NUMBER, except increment SOURCE to after the number.~~

~~- SOURCE must be an lvalue. */~~

~~-#define EXTRACT_NUMBER_AND_INCR(destination, source) \~~

~~- do { \~~

~~- EXTRACT_NUMBER (destination, source); \~~

~~- (source) += 2; \~~

~~- } while (0)~~

~~-#ifdef DEBUG~~

~~-static void~~

~~-extract_number_and_incr (destination, source)~~

~~- int *destination;~~

~~- unsigned char **source;~~

~~- extract_number (destination, *source);~~

~~- *source += 2;~~

~~-#ifndef EXTRACT_MACROS~~

~~-#undef EXTRACT_NUMBER_AND_INCR~~

~~-#define EXTRACT_NUMBER_AND_INCR(dest, src) \~~

~~- extract_number_and_incr (&dest, &src)~~

~~-#endif /* not EXTRACT_MACROS */~~

~~-#endif /* DEBUG */~~

~~-/* If DEBUG is defined, Regex prints many voluminous messages about what~~

~~- it is doing (if the variable `debug' is nonzero). If linked with the~~

~~- main program in `iregex.c', you can enter patterns and strings~~

~~- interactively. And if linked with the main program in `main.c' and~~

~~- the other test files, you can run the already-written tests. */~~

~~-#ifdef DEBUG~~

~~-/* We use standard I/O for debugging. */~~

~~-#include <stdio.h>~~

~~-/* It is useful to test things that ``must'' be true when debugging. */~~

~~-#include <assert.h>~~

~~-static int debug = 0;~~

~~-#define DEBUG_STATEMENT(e) e~~

~~-#define DEBUG_PRINT1(x) if (debug) printf (x)~~

~~-#define DEBUG_PRINT2(x1, x2) if (debug) printf (x1, x2)~~

~~-#define DEBUG_PRINT3(x1, x2, x3) if (debug) printf (x1, x2, x3)~~

~~-#define DEBUG_PRINT4(x1, x2, x3, x4) if (debug) printf (x1, x2, x3, x4)~~

~~-#define DEBUG_PRINT_COMPILED_PATTERN(p, s, e) \~~

~~- if (debug) print_partial_compiled_pattern (s, e)~~

~~-#define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2) \~~

~~- if (debug) print_double_string (w, s1, sz1, s2, sz2)~~

~~-extern void printchar ();~~

~~-/* Print the fastmap in human-readable form. */~~

~~-void~~

~~-print_fastmap (fastmap)~~

~~- char *fastmap;~~

~~- unsigned was_a_range = 0;~~

~~- unsigned i = 0;~~

~~- while (i < (1 << BYTEWIDTH))~~

~~- {~~

~~- if (fastmap[i++])~~

~~- {~~

~~- was_a_range = 0;~~

~~- printchar (i - 1);~~

~~- while (i < (1 << BYTEWIDTH) && fastmap[i])~~

~~- {~~

~~- was_a_range = 1;~~

~~- i++;~~

~~- }~~

~~- if (was_a_range)~~

~~- {~~

~~- printf ("-");~~

~~- printchar (i - 1);~~

~~- }~~

~~- putchar ('\n');~~

~~-/* Print a compiled pattern string in human-readable form, starting at~~

~~- the START pointer into it and ending just before the pointer END. */~~

~~-void~~

~~-print_partial_compiled_pattern (start, end)~~

~~- unsigned char *start;~~

~~- unsigned char *end;~~

~~- int mcnt, mcnt2;~~

~~- unsigned char *p = start;~~

~~- unsigned char *pend = end;~~

~~- if (start == NULL)~~

~~- {~~

~~- printf ("(null)\n");~~

~~- return;~~

~~- }~~

~~- /* Loop over pattern commands. */~~

~~- while (p < pend)~~

~~- {~~

~~- switch ((re_opcode_t) *p++)~~

~~- {~~

~~- case no_op:~~

~~- printf ("/no_op");~~

~~- break;~~

~~- case exactn:~~

~~- mcnt = *p++;~~

~~- printf ("/exactn/%d", mcnt);~~

~~- do~~

~~- {~~

~~- putchar ('/');~~

~~- printchar (*p++);~~

~~- }~~

~~- while (--mcnt);~~

~~- break;~~

~~- case start_memory:~~

~~- mcnt = *p++;~~

~~- printf ("/start_memory/%d/%d", mcnt, *p++);~~

~~- break;~~

~~- case stop_memory:~~

~~- mcnt = *p++;~~

~~- printf ("/stop_memory/%d/%d", mcnt, *p++);~~

~~- break;~~

~~- case duplicate:~~

~~- printf ("/duplicate/%d", *p++);~~

~~- break;~~

~~- case anychar:~~

~~- printf ("/anychar");~~

~~- break;~~

~~- case charset:~~

~~- case charset_not:~~

~~- {~~

~~- register int c;~~

~~- printf ("/charset%s",~~

~~- (re_opcode_t) *(p - 1) == charset_not ? "_not" : "");~~

~~- assert (p + *p < pend);~~

~~- for (c = 0; c < *p; c++)~~

~~- {~~

~~- unsigned bit;~~

~~- unsigned char map_byte = p[1 + c];~~

~~- putchar ('/');~~

~~- for (bit = 0; bit < BYTEWIDTH; bit++)~~

~~- if (map_byte & (1 << bit))~~

~~- printchar (c * BYTEWIDTH + bit);~~

~~- }~~

~~- p += 1 + *p;~~

~~- break;~~

~~- }~~

~~- case begline:~~

~~- printf ("/begline");~~

~~- break;~~

~~- case endline:~~

~~- printf ("/endline");~~

~~- break;~~

~~- case on_failure_jump:~~

~~- extract_number_and_incr (&mcnt, &p);~~

~~- printf ("/on_failure_jump/0/%d", mcnt);~~

~~- break;~~

~~- case on_failure_keep_string_jump:~~

~~- extract_number_and_incr (&mcnt, &p);~~

~~- printf ("/on_failure_keep_string_jump/0/%d", mcnt);~~

~~- break;~~

~~- case dummy_failure_jump:~~

~~- extract_number_and_incr (&mcnt, &p);~~

~~- printf ("/dummy_failure_jump/0/%d", mcnt);~~

~~- break;~~

~~- case push_dummy_failure:~~

~~- printf ("/push_dummy_failure");~~

~~- break;~~

~~- case maybe_pop_jump:~~

~~- extract_number_and_incr (&mcnt, &p);~~

~~- printf ("/maybe_pop_jump/0/%d", mcnt);~~

~~- break;~~

~~- case pop_failure_jump:~~

~~- extract_number_and_incr (&mcnt, &p);~~

~~- printf ("/pop_failure_jump/0/%d", mcnt);~~

~~- break;~~

~~- case jump_past_alt:~~

~~- extract_number_and_incr (&mcnt, &p);~~

~~- printf ("/jump_past_alt/0/%d", mcnt);~~

~~- break;~~

~~- case jump:~~

~~- extract_number_and_incr (&mcnt, &p);~~

~~- printf ("/jump/0/%d", mcnt);~~

~~- break;~~

~~- case succeed_n:~~

~~- extract_number_and_incr (&mcnt, &p);~~

~~- extract_number_and_incr (&mcnt2, &p);~~

~~- printf ("/succeed_n/0/%d/0/%d", mcnt, mcnt2);~~

~~- break;~~

~~- case jump_n:~~

~~- extract_number_and_incr (&mcnt, &p);~~

~~- extract_number_and_incr (&mcnt2, &p);~~

~~- printf ("/jump_n/0/%d/0/%d", mcnt, mcnt2);~~

~~- break;~~

~~- case set_number_at:~~

~~- extract_number_and_incr (&mcnt, &p);~~

~~- extract_number_and_incr (&mcnt2, &p);~~

~~- printf ("/set_number_at/0/%d/0/%d", mcnt, mcnt2);~~

~~- break;~~

~~- case wordbound:~~

~~- printf ("/wordbound");~~

~~- break;~~

~~- case notwordbound:~~

~~- printf ("/notwordbound");~~

~~- break;~~

~~- case wordbeg:~~

~~- printf ("/wordbeg");~~

~~- break;~~

~~- case wordend:~~

~~- printf ("/wordend");~~

~~-#ifdef emacs~~

~~- case before_dot:~~

~~- printf ("/before_dot");~~

~~- break;~~

~~- case at_dot:~~

~~- printf ("/at_dot");~~

~~- break;~~

~~- case after_dot:~~

~~- printf ("/after_dot");~~

~~- break;~~

~~- case syntaxspec:~~

~~- printf ("/syntaxspec");~~

~~- mcnt = *p++;~~

~~- printf ("/%d", mcnt);~~

~~- break;~~

~~- case notsyntaxspec:~~

~~- printf ("/notsyntaxspec");~~

~~- mcnt = *p++;~~

~~- printf ("/%d", mcnt);~~

~~- break;~~

~~-#endif /* emacs */~~

~~- case wordchar:~~

~~- printf ("/wordchar");~~

~~- break;~~

~~- case notwordchar:~~

~~- printf ("/notwordchar");~~

~~- break;~~

~~- case begbuf:~~

~~- printf ("/begbuf");~~

~~- break;~~

~~- case endbuf:~~

~~- printf ("/endbuf");~~

~~- break;~~

~~- default:~~

~~- printf ("?%d", *(p-1));~~

~~- }~~

~~- printf ("/\n");~~

~~-void~~

~~-print_compiled_pattern (bufp)~~

~~- struct re_pattern_buffer *bufp;~~

~~- unsigned char *buffer = bufp->buffer;~~

~~- print_partial_compiled_pattern (buffer, buffer + bufp->used);~~

~~- printf ("%d bytes used/%d bytes allocated.\n", bufp->used, bufp->allocated);~~

~~- if (bufp->fastmap_accurate && bufp->fastmap)~~

~~- {~~

~~- printf ("fastmap: ");~~

~~- print_fastmap (bufp->fastmap);~~

~~- }~~

~~- printf ("re_nsub: %d\t", bufp->re_nsub);~~

~~- printf ("regs_alloc: %d\t", bufp->regs_allocated);~~

~~- printf ("can_be_null: %d\t", bufp->can_be_null);~~

~~- printf ("newline_anchor: %d\n", bufp->newline_anchor);~~

~~- printf ("no_sub: %d\t", bufp->no_sub);~~

~~- printf ("not_bol: %d\t", bufp->not_bol);~~

~~- printf ("not_eol: %d\t", bufp->not_eol);~~

~~- printf ("syntax: %d\n", bufp->syntax);~~

~~- /* Perhaps we should print the translate table? */~~

~~-void~~

~~-print_double_string (where, string1, size1, string2, size2)~~

~~- const char *where;~~

~~- const char *string1;~~

~~- const char *string2;~~

~~- int size1;~~

~~- int size2;~~

~~- unsigned this_char;~~

~~- if (where == NULL)~~

~~- printf ("(null)");~~

~~- else~~

~~- {~~

~~- if (FIRST_STRING_P (where))~~

~~- {~~

~~- for (this_char = where - string1; this_char < size1; this_char++)~~

~~- printchar (string1[this_char]);~~

~~- where = string2;~~

~~- }~~

~~- for (this_char = where - string2; this_char < size2; this_char++)~~

~~- printchar (string2[this_char]);~~

~~- }~~

~~-#else /* not DEBUG */~~

~~-#undef assert~~

~~-#define assert(e)~~

~~-#define DEBUG_STATEMENT(e)~~

~~-#define DEBUG_PRINT1(x)~~

~~-#define DEBUG_PRINT2(x1, x2)~~

~~-#define DEBUG_PRINT3(x1, x2, x3)~~

~~-#define DEBUG_PRINT4(x1, x2, x3, x4)~~

~~-#define DEBUG_PRINT_COMPILED_PATTERN(p, s, e)~~

~~-#define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2)~~

~~-#endif /* not DEBUG */~~

~~-/* Set by `re_set_syntax' to the current regexp syntax to recognize. Can~~

~~- also be assigned to arbitrarily: each pattern buffer stores its own~~

~~- syntax, so it can be changed between regex compilations. */~~

~~-reg_syntax_t re_syntax_options = RE_SYNTAX_EMACS;~~

~~-/* Specify the precise syntax of regexps for compilation. This provides~~

~~- for compatibility for various utilities which historically have~~

~~- different, incompatible syntaxes.~~

~~- The argument SYNTAX is a bit mask comprised of the various bits~~

~~- defined in regex.h. We return the old syntax. */~~

~~-reg_syntax_t~~

~~-re_set_syntax (syntax)~~

~~- reg_syntax_t syntax;~~

~~- reg_syntax_t ret = re_syntax_options;~~

~~- re_syntax_options = syntax;~~

~~- return ret;~~

~~-/* This table gives an error message for each of the error codes listed~~

~~- in regex.h. Obviously the order here has to be same as there. */~~

~~-static const char *re_error_msg[] =~~

~~- { NULL, /* REG_NOERROR */~~

~~- "No match", /* REG_NOMATCH */~~

~~- "Invalid regular expression", /* REG_BADPAT */~~

~~- "Invalid collation character", /* REG_ECOLLATE */~~

~~- "Invalid character class name", /* REG_ECTYPE */~~

~~- "Trailing backslash", /* REG_EESCAPE */~~

~~- "Invalid back reference", /* REG_ESUBREG */~~

~~- "Unmatched [ or [^", /* REG_EBRACK */~~

~~- "Unmatched ( or \\(", /* REG_EPAREN */~~

~~- "Unmatched \\{", /* REG_EBRACE */~~

~~- "Invalid content of \\{\\}", /* REG_BADBR */~~

~~- "Invalid range end", /* REG_ERANGE */~~

~~- "Memory exhausted", /* REG_ESPACE */~~

~~- "Invalid preceding regular expression", /* REG_BADRPT */~~

~~- "Premature end of regular expression", /* REG_EEND */~~

~~- "Regular expression too big", /* REG_ESIZE */~~

~~- "Unmatched ) or \\)", /* REG_ERPAREN */~~

~~- };~~

~~-/* Subroutine declarations and macros for regex_compile. */~~

~~-static void store_op1 (), store_op2 ();~~

~~-static void insert_op1 (), insert_op2 ();~~

~~-static boolean at_begline_loc_p (), at_endline_loc_p ();~~

~~-static boolean group_in_compile_stack ();~~

~~-static reg_errcode_t compile_range ();~~

~~-/* Fetch the next character in the uncompiled pattern---translating it~~

~~- if necessary. Also cast from a signed character in the constant~~

~~- string passed to us by the user to an unsigned char that we can use~~

~~- as an array index (in, e.g., `translate'). */~~

~~-#define PATFETCH(c) \~~

~~- do {if (p == pend) return REG_EEND; \~~

~~- c = (unsigned char) *p++; \~~

~~- if (translate) c = translate[c]; \~~

~~- } while (0)~~

~~-/* Fetch the next character in the uncompiled pattern, with no~~

~~- translation. */~~

~~-#define PATFETCH_RAW(c) \~~

~~- do {if (p == pend) return REG_EEND; \~~

~~- c = (unsigned char) *p++; \~~

~~- } while (0)~~

~~-/* Go backwards one character in the pattern. */~~

~~-#define PATUNFETCH p--~~

~~-/* If `translate' is non-null, return translate[D], else just D. We~~

~~- cast the subscript to translate because some data is declared as~~

~~- `char *', to avoid warnings when a string constant is passed. But~~

~~- when we use a character as a subscript we must make it unsigned. */~~

~~-#define TRANSLATE(d) (translate ? translate[(unsigned char) (d)] : (d))~~

~~-/* Macros for outputting the compiled pattern into `buffer'. */~~

~~-/* If the buffer isn't allocated when it comes in, use this. */~~

~~-#define INIT_BUF_SIZE 32~~

~~-/* Make sure we have at least N more bytes of space in buffer. */~~

~~-#define GET_BUFFER_SPACE(n) \~~

~~- while (b - bufp->buffer + (n) > bufp->allocated) \~~

~~- EXTEND_BUFFER ()~~

~~-/* Make sure we have one more byte of buffer space and then add C to it. */~~

~~-#define BUF_PUSH(c) \~~

~~- do { \~~

~~- GET_BUFFER_SPACE (1); \~~

~~- *b++ = (unsigned char) (c); \~~

~~- } while (0)~~

~~-/* Ensure we have two more bytes of buffer space and then append C1 and C2. */~~

~~-#define BUF_PUSH_2(c1, c2) \~~

~~- do { \~~

~~- GET_BUFFER_SPACE (2); \~~

~~- *b++ = (unsigned char) (c1); \~~

~~- *b++ = (unsigned char) (c2); \~~

~~- } while (0)~~

~~-/* As with BUF_PUSH_2, except for three bytes. */~~

~~-#define BUF_PUSH_3(c1, c2, c3) \~~

~~- do { \~~

~~- GET_BUFFER_SPACE (3); \~~

~~- *b++ = (unsigned char) (c1); \~~

~~- *b++ = (unsigned char) (c2); \~~

~~- *b++ = (unsigned char) (c3); \~~

~~- } while (0)~~

~~-/* Store a jump with opcode OP at LOC to location TO. We store a~~

~~- relative address offset by the three bytes the jump itself occupies. */~~

~~-#define STORE_JUMP(op, loc, to) \~~

~~- store_op1 (op, loc, (to) - (loc) - 3)~~

~~-/* Likewise, for a two-argument jump. */~~

~~-#define STORE_JUMP2(op, loc, to, arg) \~~

~~- store_op2 (op, loc, (to) - (loc) - 3, arg)~~

~~-/* Like `STORE_JUMP', but for inserting. Assume `b' is the buffer end. */~~

~~-#define INSERT_JUMP(op, loc, to) \~~

~~- insert_op1 (op, loc, (to) - (loc) - 3, b)~~

~~-/* Like `STORE_JUMP2', but for inserting. Assume `b' is the buffer end. */~~

~~-#define INSERT_JUMP2(op, loc, to, arg) \~~

~~- insert_op2 (op, loc, (to) - (loc) - 3, arg, b)~~

~~-/* This is not an arbitrary limit: the arguments which represent offsets~~

~~- into the pattern are two bytes long. So if 2^16 bytes turns out to~~

~~- be too small, many things would have to change. */~~

~~-#define MAX_BUF_SIZE (1L << 16)~~

~~-/* Extend the buffer by twice its current size via realloc and~~

~~- reset the pointers that pointed into the old block to point to the~~

~~- correct places in the new one. If extending the buffer results in it~~

~~- being larger than MAX_BUF_SIZE, then flag memory exhausted. */~~

~~-#define EXTEND_BUFFER() \~~

~~- do { \~~

~~- unsigned char *old_buffer = bufp->buffer; \~~

~~- if (bufp->allocated == MAX_BUF_SIZE) \~~

~~- return REG_ESIZE; \~~

~~- bufp->allocated <<= 1; \~~

~~- if (bufp->allocated > MAX_BUF_SIZE) \~~

~~- bufp->allocated = MAX_BUF_SIZE; \~~

~~- bufp->buffer = (unsigned char *) realloc (bufp->buffer, bufp->allocated);\~~

~~- if (bufp->buffer == NULL) \~~

~~- return REG_ESPACE; \~~

~~- /* If the buffer moved, move all the pointers into it. */ \~~

~~- if (old_buffer != bufp->buffer) \~~

~~- { \~~

~~- b = (b - old_buffer) + bufp->buffer; \~~

~~- begalt = (begalt - old_buffer) + bufp->buffer; \~~

~~- if (fixup_alt_jump) \~~

~~- fixup_alt_jump = (fixup_alt_jump - old_buffer) + bufp->buffer;\~~

~~- if (laststart) \~~

~~- laststart = (laststart - old_buffer) + bufp->buffer; \~~

~~- if (pending_exact) \~~

~~- pending_exact = (pending_exact - old_buffer) + bufp->buffer; \~~

~~- } \~~

~~- } while (0)~~

~~-/* Since we have one byte reserved for the register number argument to~~

~~- {start,stop}_memory, the maximum number of groups we can report~~

~~- things about is what fits in that byte. */~~

~~-#define MAX_REGNUM 255~~

~~-/* But patterns can have more than `MAX_REGNUM' registers. We just~~

~~- ignore the excess. */~~

~~-typedef unsigned regnum_t;~~

~~-/* Macros for the compile stack. */~~

~~-/* Since offsets can go either forwards or backwards, this type needs to~~

~~- be able to hold values from -(MAX_BUF_SIZE - 1) to MAX_BUF_SIZE - 1. */~~

~~-typedef int pattern_offset_t;~~

~~-typedef struct~~

~~- pattern_offset_t begalt_offset;~~

~~- pattern_offset_t fixup_alt_jump;~~

~~- pattern_offset_t inner_group_offset;~~

~~- pattern_offset_t laststart_offset;~~

~~- regnum_t regnum;~~

~~-} compile_stack_elt_t;~~

~~-typedef struct~~

~~- compile_stack_elt_t *stack;~~

~~- unsigned size;~~

~~- unsigned avail; /* Offset of next open position. */~~

~~-} compile_stack_type;~~

~~-#define INIT_COMPILE_STACK_SIZE 32~~

~~-#define COMPILE_STACK_EMPTY (compile_stack.avail == 0)~~

~~-#define COMPILE_STACK_FULL (compile_stack.avail == compile_stack.size)~~

~~-/* The next available element. */~~

~~-#define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail])~~

~~-/* Set the bit for character C in a list. */~~

~~-#define SET_LIST_BIT(c) \~~

~~- (b[((unsigned char) (c)) / BYTEWIDTH] \~~

~~- |= 1 << (((unsigned char) c) % BYTEWIDTH))~~

~~-/* Get the next unsigned number in the uncompiled pattern. */~~

~~-#define GET_UNSIGNED_NUMBER(num) \~~

~~- { if (p != pend) \~~

~~- { \~~

~~- PATFETCH (c); \~~

~~- while (ISDIGIT (c)) \~~

~~- { \~~

~~- if (num < 0) \~~

~~- num = 0; \~~

~~- num = num * 10 + c - '0'; \~~

~~- if (p == pend) \~~

~~- break; \~~

~~- PATFETCH (c); \~~

~~- } \~~

~~- }~~

~~-#define CHAR_CLASS_MAX_LENGTH 6 /* Namely, `xdigit'. */~~

~~-#define IS_CHAR_CLASS(string) \~~

~~- (STREQ (string, "alpha") || STREQ (string, "upper") \~~

~~- || STREQ (string, "lower") || STREQ (string, "digit") \~~

~~- || STREQ (string, "alnum") || STREQ (string, "xdigit") \~~

~~- || STREQ (string, "space") || STREQ (string, "print") \~~

~~- || STREQ (string, "punct") || STREQ (string, "graph") \~~

~~- || STREQ (string, "cntrl") || STREQ (string, "blank"))~~

~~-/* `regex_compile' compiles PATTERN (of length SIZE) according to SYNTAX.~~

~~- Returns one of error codes defined in `regex.h', or zero for success.~~

~~- Assumes the `allocated' (and perhaps `buffer') and `translate'~~

~~- fields are set in BUFP on entry.~~

~~- If it succeeds, results are put in BUFP (if it returns an error, the~~

~~- contents of BUFP are undefined):~~

~~- `buffer' is the compiled pattern;~~

~~- `syntax' is set to SYNTAX;~~

~~- `used' is set to the length of the compiled pattern;~~

~~- `fastmap_accurate' is zero;~~

~~- `re_nsub' is the number of subexpressions in PATTERN;~~

~~- `not_bol' and `not_eol' are zero;~~

~~- The `fastmap' and `newline_anchor' fields are neither~~

~~- examined nor set. */~~

~~-static reg_errcode_t~~

~~-regex_compile (pattern, size, syntax, bufp)~~

~~- const char *pattern;~~

~~- int size;~~

~~- reg_syntax_t syntax;~~

~~- struct re_pattern_buffer *bufp;~~

~~- /* We fetch characters from PATTERN here. Even though PATTERN is~~

~~- `char *' (i.e., signed), we declare these variables as unsigned, so~~

~~- they can be reliably used as array indices. */~~

~~- register unsigned char c, c1;~~

~~- /* A random tempory spot in PATTERN. */~~

~~- const char *p1;~~

~~- /* Points to the end of the buffer, where we should append. */~~

~~- register unsigned char *b;~~

~~- /* Keeps track of unclosed groups. */~~

~~- compile_stack_type compile_stack;~~

~~- /* Points to the current (ending) position in the pattern. */~~

~~- const char *p = pattern;~~

~~- const char *pend = pattern + size;~~

~~- /* How to translate the characters in the pattern. */~~

~~- char *translate = bufp->translate;~~

~~- /* Address of the count-byte of the most recently inserted `exactn'~~

~~- command. This makes it possible to tell if a new exact-match~~

~~- character can be added to that command or if the character requires~~

~~- a new `exactn' command. */~~

~~- unsigned char *pending_exact = 0;~~

~~- /* Address of start of the most recently finished expression.~~

~~- This tells, e.g., postfix * where to find the start of its~~

~~- operand. Reset at the beginning of groups and alternatives. */~~

~~- unsigned char *laststart = 0;~~

~~- /* Address of beginning of regexp, or inside of last group. */~~

~~- unsigned char *begalt;~~

~~- /* Place in the uncompiled pattern (i.e., the {) to~~

~~- which to go back if the interval is invalid. */~~

~~- const char *beg_interval;~~

~~- /* Address of the place where a forward jump should go to the end of~~

~~- the containing expression. Each alternative of an `or' -- except the~~

~~- last -- ends with a forward jump of this sort. */~~

~~- unsigned char *fixup_alt_jump = 0;~~

~~- /* Counts open-groups as they are encountered. Remembered for the~~

~~- matching close-group on the compile stack, so the same register~~

~~- number is put in the stop_memory as the start_memory. */~~

~~- regnum_t regnum = 0;~~

~~-#ifdef DEBUG~~

~~- DEBUG_PRINT1 ("\nCompiling pattern: ");~~

~~- if (debug)~~

~~- {~~

~~- unsigned debug_count;~~

~~- for (debug_count = 0; debug_count < size; debug_count++)~~

~~- printchar (pattern[debug_count]);~~

~~- putchar ('\n');~~

~~- }~~

~~-#endif /* DEBUG */~~

~~- /* Initialize the compile stack. */~~

~~- compile_stack.stack = TALLOC (INIT_COMPILE_STACK_SIZE, compile_stack_elt_t);~~

~~- if (compile_stack.stack == NULL)~~

~~- return REG_ESPACE;~~

~~- compile_stack.size = INIT_COMPILE_STACK_SIZE;~~

~~- compile_stack.avail = 0;~~

~~- /* Initialize the pattern buffer. */~~

~~- bufp->syntax = syntax;~~

~~- bufp->fastmap_accurate = 0;~~

~~- bufp->not_bol = bufp->not_eol = 0;~~

~~- /* Set `used' to zero, so that if we return an error, the pattern~~

~~- printer (for debugging) will think there's no pattern. We reset it~~

~~- at the end. */~~

~~- bufp->used = 0;~~

~~- /* Always count groups, whether or not bufp->no_sub is set. */~~

~~- bufp->re_nsub = 0;~~

~~-#if !defined (emacs) && !defined (SYNTAX_TABLE)~~

~~- /* Initialize the syntax table. */~~

~~- init_syntax_once ();~~

~~-#endif~~

~~- if (bufp->allocated == 0)~~

~~- {~~

~~- if (bufp->buffer)~~

~~- { /* If zero allocated, but buffer is non-null, try to realloc~~

~~- enough space. This loses if buffer's address is bogus, but~~

~~- that is the user's responsibility. */~~

~~- RETALLOC (bufp->buffer, INIT_BUF_SIZE, unsigned char);~~

~~- }~~

~~- else~~

~~- { /* Caller did not allocate a buffer. Do it for them. */~~

~~- bufp->buffer = TALLOC (INIT_BUF_SIZE, unsigned char);~~

~~- }~~

~~- if (!bufp->buffer) return REG_ESPACE;~~

~~- bufp->allocated = INIT_BUF_SIZE;~~

~~- }~~

~~- begalt = b = bufp->buffer;~~

~~- /* Loop through the uncompiled pattern until we're at the end. */~~

~~- while (p != pend)~~

~~- {~~

~~- PATFETCH (c);~~

~~- switch (c)~~

~~- {~~

~~- case '^':~~

~~- {~~

~~- if ( /* If at start of pattern, it's an operator. */~~

~~- p == pattern + 1~~

~~- /* If context independent, it's an operator. */~~

~~- || syntax & RE_CONTEXT_INDEP_ANCHORS~~

~~- /* Otherwise, depends on what's come before. */~~

~~- || at_begline_loc_p (pattern, p, syntax))~~

~~- BUF_PUSH (begline);~~

~~- else~~

~~- goto normal_char;~~

~~- }~~

~~- break;~~

~~- case '$':~~

~~- {~~

~~- if ( /* If at end of pattern, it's an operator. */~~

~~- p == pend~~

~~- /* If context independent, it's an operator. */~~

~~- || syntax & RE_CONTEXT_INDEP_ANCHORS~~

~~- /* Otherwise, depends on what's next. */~~

~~- || at_endline_loc_p (p, pend, syntax))~~

~~- BUF_PUSH (endline);~~

~~- else~~

~~- goto normal_char;~~

~~- }~~

~~- break;~~

~~- case '+':~~

~~- case '?':~~

~~- if ((syntax & RE_BK_PLUS_QM)~~

~~- || (syntax & RE_LIMITED_OPS))~~

~~- goto normal_char;~~

~~- handle_plus:~~

~~- case '*':~~

~~- /* If there is no previous pattern... */~~

~~- if (!laststart)~~

~~- {~~

~~- if (syntax & RE_CONTEXT_INVALID_OPS)~~

~~- return REG_BADRPT;~~

~~- else if (!(syntax & RE_CONTEXT_INDEP_OPS))~~

~~- goto normal_char;~~

~~- }~~

~~- {~~

~~- /* Are we optimizing this jump? */~~

~~- boolean keep_string_p = false;~~

~~- /* 1 means zero (many) matches is allowed. */~~

~~- char zero_times_ok = 0, many_times_ok = 0;~~

~~- /* If there is a sequence of repetition chars, collapse it~~

~~- down to just one (the right one). We can't combine~~

~~- interval operators with these because of, e.g., `a{2}*',~~

~~- which should only match an even number of `a's. */~~

~~- for (;;)~~

~~- {~~

~~- zero_times_ok |= c != '+';~~

~~- many_times_ok |= c != '?';~~

~~- if (p == pend)~~

~~- break;~~

~~- PATFETCH (c);~~

~~- if (c == '*'~~

~~- || (!(syntax & RE_BK_PLUS_QM) && (c == '+' || c == '?')))~~

~~- ;~~

~~- else if (syntax & RE_BK_PLUS_QM && c == '\\')~~

~~- {~~

~~- if (p == pend) return REG_EESCAPE;~~

~~- PATFETCH (c1);~~

~~- if (!(c1 == '+' || c1 == '?'))~~

~~- {~~

~~- PATUNFETCH;~~

~~- break;~~

~~- }~~

~~- c = c1;~~

~~- }~~

~~- else~~

~~- {~~

~~- PATUNFETCH;~~

~~- break;~~

~~- }~~

~~- /* If we get here, we found another repeat character. */~~

~~- }~~

~~- /* Star, etc. applied to an empty pattern is equivalent~~

~~- to an empty pattern. */~~

~~- if (!laststart)~~

~~- break;~~

~~- /* Now we know whether or not zero matches is allowed~~

~~- and also whether or not two or more matches is allowed. */~~

~~- if (many_times_ok)~~

~~- { /* More than one repetition is allowed, so put in at the~~

~~- end a backward relative jump from `b' to before the next~~

~~- jump we're going to put in below (which jumps from~~

~~- laststart to after this jump).~~

~~- But if we are at the `*' in the exact sequence `.*\n',~~

~~- insert an unconditional jump backwards to the .,~~

~~- instead of the beginning of the loop. This way we only~~

~~- push a failure point once, instead of every time~~

~~- through the loop. */~~

~~- assert (p - 1 > pattern);~~

~~- /* Allocate the space for the jump. */~~

~~- GET_BUFFER_SPACE (3);~~

~~- /* We know we are not at the first character of the pattern,~~

~~- because laststart was nonzero. And we've already~~

~~- incremented `p', by the way, to be the character after~~

~~- the `*'. Do we have to do something analogous here~~

~~- for null bytes, because of RE_DOT_NOT_NULL? */~~

~~- if (TRANSLATE (*(p - 2)) == TRANSLATE ('.')~~

~~- && zero_times_ok~~

~~- && p < pend && TRANSLATE (*p) == TRANSLATE ('\n')~~

~~- && !(syntax & RE_DOT_NEWLINE))~~

~~- { /* We have .*\n. */~~

~~- STORE_JUMP (jump, b, laststart);~~

~~- keep_string_p = true;~~

~~- }~~

~~- else~~

~~- /* Anything else. */~~

~~- STORE_JUMP (maybe_pop_jump, b, laststart - 3);~~

~~- /* We've added more stuff to the buffer. */~~

~~- b += 3;~~

~~- }~~

~~- /* On failure, jump from laststart to b + 3, which will be the~~

~~- end of the buffer after this jump is inserted. */~~

~~- GET_BUFFER_SPACE (3);~~

~~- INSERT_JUMP (keep_string_p ? on_failure_keep_string_jump~~

~~- : on_failure_jump,~~

~~- laststart, b + 3);~~

~~- pending_exact = 0;~~

~~- b += 3;~~

~~- if (!zero_times_ok)~~

~~- {~~

~~- /* At least one repetition is required, so insert a~~

~~- `dummy_failure_jump' before the initial~~

~~- `on_failure_jump' instruction of the loop. This~~

~~- effects a skip over that instruction the first time~~

~~- we hit that loop. */~~

~~- GET_BUFFER_SPACE (3);~~

~~- INSERT_JUMP (dummy_failure_jump, laststart, laststart + 6);~~

~~- b += 3;~~

~~- }~~

~~- break;~~

~~- case '.':~~

~~- laststart = b;~~

~~- BUF_PUSH (anychar);~~

~~- break;~~

~~- case '[':~~

~~- {~~

~~- boolean had_char_class = false;~~

~~- if (p == pend) return REG_EBRACK;~~

~~- /* Ensure that we have enough space to push a charset: the~~

~~- opcode, the length count, and the bitset; 34 bytes in all. */~~

~~- GET_BUFFER_SPACE (34);~~

~~- laststart = b;~~

~~- /* We test `*p == '^' twice, instead of using an if~~

~~- statement, so we only need one BUF_PUSH. */~~

~~- BUF_PUSH (*p == '^' ? charset_not : charset);~~

~~- if (*p == '^')~~

~~- p++;~~

~~- /* Remember the first position in the bracket expression. */~~

~~- p1 = p;~~

~~- /* Push the number of bytes in the bitmap. */~~

~~- BUF_PUSH ((1 << BYTEWIDTH) / BYTEWIDTH);~~

~~- /* Clear the whole map. */~~

~~- bzero (b, (1 << BYTEWIDTH) / BYTEWIDTH);~~

~~- /* charset_not matches newline according to a syntax bit. */~~

~~- if ((re_opcode_t) b[-2] == charset_not~~

~~- && (syntax & RE_HAT_LISTS_NOT_NEWLINE))~~

~~- SET_LIST_BIT ('\n');~~

~~- /* Read in characters and ranges, setting map bits. */~~

~~- for (;;)~~

~~- {~~

~~- if (p == pend) return REG_EBRACK;~~

~~- PATFETCH (c);~~

~~- /* \ might escape characters inside [...] and [^...]. */~~

~~- if ((syntax & RE_BACKSLASH_ESCAPE_IN_LISTS) && c == '\\')~~

~~- {~~

~~- if (p == pend) return REG_EESCAPE;~~

~~- PATFETCH (c1);~~

~~- SET_LIST_BIT (c1);~~

~~- continue;~~

~~- }~~

~~- /* Could be the end of the bracket expression. If it's~~

~~- not (i.e., when the bracket expression is `[]' so~~

~~- far), the ']' character bit gets set way below. */~~

~~- if (c == ']' && p != p1 + 1)~~

~~- break;~~

~~- /* Look ahead to see if it's a range when the last thing~~

~~- was a character class. */~~

~~- if (had_char_class && c == '-' && *p != ']')~~

~~- return REG_ERANGE;~~

~~- /* Look ahead to see if it's a range when the last thing~~

~~- was a character: if this is a hyphen not at the~~

~~- beginning or the end of a list, then it's the range~~

~~- operator. */~~

~~- if (c == '-'~~

~~- && !(p - 2 >= pattern && p[-2] == '[')~~

~~- && !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^')~~

~~- && *p != ']')~~

~~- {~~

~~- reg_errcode_t ret~~

~~- = compile_range (&p, pend, translate, syntax, b);~~

~~- if (ret != REG_NOERROR) return ret;~~

~~- }~~

~~- else if (p[0] == '-' && p[1] != ']')~~

~~- { /* This handles ranges made up of characters only. */~~

~~- reg_errcode_t ret;~~

~~- /* Move past the `-'. */~~

~~- PATFETCH (c1);~~

~~- ret = compile_range (&p, pend, translate, syntax, b);~~

~~- if (ret != REG_NOERROR) return ret;~~

~~- }~~

~~- /* See if we're at the beginning of a possible character~~

~~- class. */~~

~~- else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == ':')~~

~~- { /* Leave room for the null. */~~

~~- char str[CHAR_CLASS_MAX_LENGTH + 1];~~

~~- PATFETCH (c);~~

~~- c1 = 0;~~

~~- /* If pattern is `[[:'. */~~

~~- if (p == pend) return REG_EBRACK;~~

~~- for (;;)~~

~~- {~~

~~- PATFETCH (c);~~

~~- if (c == ':' || c == ']' || p == pend~~

~~- || c1 == CHAR_CLASS_MAX_LENGTH)~~

~~- break;~~

~~- str[c1++] = c;~~

~~- }~~

~~- str[c1] = '\0';~~

~~- /* If isn't a word bracketed by `[:' and:`]':~~

~~- undo the ending character, the letters, and leave~~

~~- the leading `:' and `[' (but set bits for them). */~~

~~- if (c == ':' && *p == ']')~~

~~- {~~

~~- int ch;~~

~~- boolean is_alnum = STREQ (str, "alnum");~~

~~- boolean is_alpha = STREQ (str, "alpha");~~

~~- boolean is_blank = STREQ (str, "blank");~~

~~- boolean is_cntrl = STREQ (str, "cntrl");~~

~~- boolean is_digit = STREQ (str, "digit");~~

~~- boolean is_graph = STREQ (str, "graph");~~

~~- boolean is_lower = STREQ (str, "lower");~~

~~- boolean is_print = STREQ (str, "print");~~

~~- boolean is_punct = STREQ (str, "punct");~~

~~- boolean is_space = STREQ (str, "space");~~

~~- boolean is_upper = STREQ (str, "upper");~~

~~- boolean is_xdigit = STREQ (str, "xdigit");~~

~~- if (!IS_CHAR_CLASS (str)) return REG_ECTYPE;~~

~~- /* Throw away the ] at the end of the character~~

~~- class. */~~

~~- PATFETCH (c);~~

~~- if (p == pend) return REG_EBRACK;~~

~~- for (ch = 0; ch < 1 << BYTEWIDTH; ch++)~~

~~- {~~

~~- if ( (is_alnum && ISALNUM (ch))~~

~~- || (is_alpha && ISALPHA (ch))~~

~~- || (is_blank && ISBLANK (ch))~~

~~- || (is_cntrl && ISCNTRL (ch))~~

~~- || (is_digit && ISDIGIT (ch))~~

~~- || (is_graph && ISGRAPH (ch))~~

~~- || (is_lower && ISLOWER (ch))~~

~~- || (is_print && ISPRINT (ch))~~

~~- || (is_punct && ISPUNCT (ch))~~

~~- || (is_space && ISSPACE (ch))~~

~~- || (is_upper && ISUPPER (ch))~~

~~- || (is_xdigit && ISXDIGIT (ch)))~~

~~- SET_LIST_BIT (ch);~~

~~- }~~

~~- had_char_class = true;~~

~~- }~~

~~- else~~

~~- {~~

~~- c1++;~~

~~- while (c1--)~~

~~- PATUNFETCH;~~

~~- SET_LIST_BIT ('[');~~

~~- SET_LIST_BIT (':');~~

~~- had_char_class = false;~~

~~- }~~

~~- else~~

~~- {~~

~~- had_char_class = false;~~

~~- SET_LIST_BIT (c);~~

~~- }~~

~~- /* Discard any (non)matching list bytes that are all 0 at the~~

~~- end of the map. Decrease the map-length byte too. */~~

~~- while ((int) b[-1] > 0 && b[b[-1] - 1] == 0)~~

~~- b[-1]--;~~

~~- b += b[-1];~~

~~- }~~

~~- break;~~

~~- case '(':~~

~~- if (syntax & RE_NO_BK_PARENS)~~

~~- goto handle_open;~~

~~- else~~

~~- goto normal_char;~~

~~- case ')':~~

~~- if (syntax & RE_NO_BK_PARENS)~~

~~- goto handle_close;~~

~~- else~~

~~- goto normal_char;~~

~~- case '\n':~~

~~- if (syntax & RE_NEWLINE_ALT)~~

~~- goto handle_alt;~~

~~- else~~

~~- goto normal_char;~~

~~- case '|':~~

~~- if (syntax & RE_NO_BK_VBAR)~~

~~- goto handle_alt;~~

~~- else~~

~~- goto normal_char;~~

~~- case '{':~~

~~- if (syntax & RE_INTERVALS && syntax & RE_NO_BK_BRACES)~~

~~- goto handle_interval;~~

~~- else~~

~~- goto normal_char;~~

~~- case '\\':~~

~~- if (p == pend) return REG_EESCAPE;~~

~~- /* Do not translate the character after the \, so that we can~~

~~- distinguish, e.g., \B from \b, even if we normally would~~

~~- translate, e.g., B to b. */~~

~~- PATFETCH_RAW (c);~~

~~- switch (c)~~

~~- {~~

~~- case '(':~~

~~- if (syntax & RE_NO_BK_PARENS)~~

~~- goto normal_backslash;~~

~~- handle_open:~~

~~- bufp->re_nsub++;~~

~~- regnum++;~~

~~- if (COMPILE_STACK_FULL)~~

~~- {~~

~~- RETALLOC (compile_stack.stack, compile_stack.size << 1,~~

~~- compile_stack_elt_t);~~

~~- if (compile_stack.stack == NULL) return REG_ESPACE;~~

~~- compile_stack.size <<= 1;~~

~~- }~~

~~- /* These are the values to restore when we hit end of this~~

~~- group. They are all relative offsets, so that if the~~

~~- whole pattern moves because of realloc, they will still~~

~~- be valid. */~~

~~- COMPILE_STACK_TOP.begalt_offset = begalt - bufp->buffer;~~

~~- COMPILE_STACK_TOP.fixup_alt_jump~~

~~- = fixup_alt_jump ? fixup_alt_jump - bufp->buffer + 1 : 0;~~

~~- COMPILE_STACK_TOP.laststart_offset = b - bufp->buffer;~~

~~- COMPILE_STACK_TOP.regnum = regnum;~~

~~- /* We will eventually replace the 0 with the number of~~

~~- groups inner to this one. But do not push a~~

~~- start_memory for groups beyond the last one we can~~

~~- represent in the compiled pattern. */~~

~~- if (regnum <= MAX_REGNUM)~~

~~- {~~

~~- COMPILE_STACK_TOP.inner_group_offset = b - bufp->buffer + 2;~~

~~- BUF_PUSH_3 (start_memory, regnum, 0);~~

~~- }~~

~~- compile_stack.avail++;~~

~~- fixup_alt_jump = 0;~~

~~- laststart = 0;~~

~~- begalt = b;~~

~~- /* If we've reached MAX_REGNUM groups, then this open~~

~~- won't actually generate any code, so we'll have to~~

~~- clear pending_exact explicitly. */~~

~~- pending_exact = 0;~~

~~- break;~~

~~- case ')':~~

~~- if (syntax & RE_NO_BK_PARENS) goto normal_backslash;~~

~~- if (COMPILE_STACK_EMPTY){~~

~~- if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD){~~

~~- goto normal_backslash;~~

~~- }else{~~

~~- return REG_ERPAREN;~~

~~- }~~

~~- handle_close:~~

~~- if (fixup_alt_jump)~~

~~- { /* Push a dummy failure point at the end of the~~

~~- alternative for a possible future~~

~~- `pop_failure_jump' to pop. See comments at~~

~~- `push_dummy_failure' in `re_match_2'. */~~

~~- BUF_PUSH (push_dummy_failure);~~

~~- /* We allocated space for this jump when we assigned~~

~~- to `fixup_alt_jump', in the `handle_alt' case below. */~~

~~- STORE_JUMP (jump_past_alt, fixup_alt_jump, b - 1);~~

~~- }~~

~~- /* See similar code for backslashed left paren above. */~~

~~- if (COMPILE_STACK_EMPTY){~~

~~- if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD){~~

~~- goto normal_char;~~

~~- }else{~~

~~- return REG_ERPAREN;~~

~~- }~~

~~- /* Since we just checked for an empty stack above, this~~

~~- ``can't happen''. */~~

~~- assert (compile_stack.avail != 0);~~

~~- {~~

~~- /* We don't just want to restore into `regnum', because~~

~~- later groups should continue to be numbered higher,~~

~~- as in `(ab)c(de)' -- the second group is #2. */~~

~~- regnum_t this_group_regnum;~~

~~- compile_stack.avail--;~~

~~- begalt = bufp->buffer + COMPILE_STACK_TOP.begalt_offset;~~

~~- fixup_alt_jump~~

~~- = COMPILE_STACK_TOP.fixup_alt_jump~~

~~- ? bufp->buffer + COMPILE_STACK_TOP.fixup_alt_jump - 1~~

~~- : 0;~~

~~- laststart = bufp->buffer + COMPILE_STACK_TOP.laststart_offset;~~

~~- this_group_regnum = COMPILE_STACK_TOP.regnum;~~

~~- /* If we've reached MAX_REGNUM groups, then this open~~

~~- won't actually generate any code, so we'll have to~~

~~- clear pending_exact explicitly. */~~

~~- pending_exact = 0;~~

~~- /* We're at the end of the group, so now we know how many~~

~~- groups were inside this one. */~~

~~- if (this_group_regnum <= MAX_REGNUM)~~

~~- {~~

~~- unsigned char *inner_group_loc~~

~~- = bufp->buffer + COMPILE_STACK_TOP.inner_group_offset;~~

~~- *inner_group_loc = regnum - this_group_regnum;~~

~~- BUF_PUSH_3 (stop_memory, this_group_regnum,~~

~~- regnum - this_group_regnum);~~

~~- }~~

~~- break;~~

~~- case '|': /* `\|'. */~~

~~- if (syntax & RE_LIMITED_OPS || syntax & RE_NO_BK_VBAR)~~

~~- goto normal_backslash;~~

~~- handle_alt:~~

~~- if (syntax & RE_LIMITED_OPS)~~

~~- goto normal_char;~~

~~- /* Insert before the previous alternative a jump which~~

~~- jumps to this alternative if the former fails. */~~

~~- GET_BUFFER_SPACE (3);~~

~~- INSERT_JUMP (on_failure_jump, begalt, b + 6);~~

~~- pending_exact = 0;~~

~~- b += 3;~~

~~- /* The alternative before this one has a jump after it~~

~~- which gets executed if it gets matched. Adjust that~~

~~- jump so it will jump to this alternative's analogous~~

~~- jump (put in below, which in turn will jump to the next~~

~~- (if any) alternative's such jump, etc.). The last such~~

~~- jump jumps to the correct final destination. A picture:~~

~~- _____ _____~~

~~- | | | |~~

~~- | v | v~~

~~- a | b | c~~

~~- If we are at `b', then fixup_alt_jump right now points to a~~

~~- three-byte space after `a'. We'll put in the jump, set~~

~~- fixup_alt_jump to right after `b', and leave behind three~~

~~- bytes which we'll fill in when we get to after `c'. */~~

~~- if (fixup_alt_jump)~~

~~- STORE_JUMP (jump_past_alt, fixup_alt_jump, b);~~

~~- /* Mark and leave space for a jump after this alternative,~~

~~- to be filled in later either by next alternative or~~

~~- when know we're at the end of a series of alternatives. */~~

~~- fixup_alt_jump = b;~~

~~- GET_BUFFER_SPACE (3);~~

~~- b += 3;~~

~~- laststart = 0;~~

~~- begalt = b;~~

~~- break;~~

~~- case '{':~~

~~- /* If \{ is a literal. */~~

~~- if (!(syntax & RE_INTERVALS)~~

~~- /* If we're at `\{' and it's not the open-interval~~

~~- operator. */~~

~~- || ((syntax & RE_INTERVALS) && (syntax & RE_NO_BK_BRACES))~~

~~- || (p - 2 == pattern && p == pend))~~

~~- goto normal_backslash;~~

~~- handle_interval:~~

~~- {~~

~~- /* If got here, then the syntax allows intervals. */~~

~~- /* At least (most) this many matches must be made. */~~

~~- int lower_bound = -1, upper_bound = -1;~~

~~- beg_interval = p - 1;~~

~~- if (p == pend)~~

~~- {~~

~~- if (syntax & RE_NO_BK_BRACES)~~

~~- goto unfetch_interval;~~

~~- else~~

~~- return REG_EBRACE;~~

~~- }~~

~~- GET_UNSIGNED_NUMBER (lower_bound);~~

~~- if (c == ',')~~

~~- {~~

~~- GET_UNSIGNED_NUMBER (upper_bound);~~

~~- if (upper_bound < 0) upper_bound = RE_DUP_MAX;~~

~~- }~~

~~- else~~

~~- /* Interval such as `{1}' => match exactly once. */~~

~~- upper_bound = lower_bound;~~

~~- if (lower_bound < 0 || upper_bound > RE_DUP_MAX~~

~~- || lower_bound > upper_bound)~~

~~- {~~

~~- if (syntax & RE_NO_BK_BRACES)~~

~~- goto unfetch_interval;~~

~~- else~~

~~- return REG_BADBR;~~

~~- }~~

~~- if (!(syntax & RE_NO_BK_BRACES))~~

~~- {~~

~~- if (c != '\\') return REG_EBRACE;~~

~~- PATFETCH (c);~~

~~- }~~

~~- if (c != '}')~~

~~- {~~

~~- if (syntax & RE_NO_BK_BRACES)~~

~~- goto unfetch_interval;~~

~~- else~~

~~- return REG_BADBR;~~

~~- }~~

~~- /* We just parsed a valid interval. */~~

~~- /* If it's invalid to have no preceding re. */~~

~~- if (!laststart)~~

~~- {~~

~~- if (syntax & RE_CONTEXT_INVALID_OPS)~~

~~- return REG_BADRPT;~~

~~- else if (syntax & RE_CONTEXT_INDEP_OPS)~~

~~- laststart = b;~~

~~- else~~

~~- goto unfetch_interval;~~

~~- }~~

~~- /* If the upper bound is zero, don't want to succeed at~~

~~- all; jump from `laststart' to `b + 3', which will be~~

~~- the end of the buffer after we insert the jump. */~~

~~- if (upper_bound == 0)~~

~~- {~~

~~- GET_BUFFER_SPACE (3);~~

~~- INSERT_JUMP (jump, laststart, b + 3);~~

~~- b += 3;~~

~~- }~~

~~- /* Otherwise, we have a nontrivial interval. When~~

~~- we're all done, the pattern will look like:~~

~~- set_number_at <jump count> <upper bound>~~

~~- set_number_at <succeed_n count> <lower bound>~~

~~- succeed_n <after jump addr> <succed_n count>~~

~~- <body of loop>~~

~~- jump_n <succeed_n addr> <jump count>~~

~~- (The upper bound and `jump_n' are omitted if~~

~~- `upper_bound' is 1, though.) */~~

~~- else~~

~~- { /* If the upper bound is > 1, we need to insert~~

~~- more at the end of the loop. */~~

~~- unsigned nbytes = 10 + (upper_bound > 1) * 10;~~

~~- GET_BUFFER_SPACE (nbytes);~~

~~- /* Initialize lower bound of the `succeed_n', even~~

~~- though it will be set during matching by its~~

~~- attendant `set_number_at' (inserted next),~~

~~- because `re_compile_fastmap' needs to know.~~

~~- Jump to the `jump_n' we might insert below. */~~

~~- INSERT_JUMP2 (succeed_n, laststart,~~

~~- b + 5 + (upper_bound > 1) * 5,~~

~~- lower_bound);~~

~~- b += 5;~~

~~- /* Code to initialize the lower bound. Insert~~

~~- before the `succeed_n'. The `5' is the last two~~

~~- bytes of this `set_number_at', plus 3 bytes of~~

~~- the following `succeed_n'. */~~

~~- insert_op2 (set_number_at, laststart, 5, lower_bound, b);~~

~~- b += 5;~~

~~- if (upper_bound > 1)~~

~~- { /* More than one repetition is allowed, so~~

~~- append a backward jump to the `succeed_n'~~

~~- that starts this interval.~~

~~- When we've reached this during matching,~~

~~- we'll have matched the interval once, so~~

~~- jump back only `upper_bound - 1' times. */~~

~~- STORE_JUMP2 (jump_n, b, laststart + 5,~~

~~- upper_bound - 1);~~

~~- b += 5;~~

~~- /* The location we want to set is the second~~

~~- parameter of the `jump_n'; that is `b-2' as~~

~~- an absolute address. `laststart' will be~~

~~- the `set_number_at' we're about to insert;~~

~~- `laststart+3' the number to set, the source~~

~~- for the relative address. But we are~~

~~- inserting into the middle of the pattern --~~

~~- so everything is getting moved up by 5.~~

~~- Conclusion: (b - 2) - (laststart + 3) + 5,~~

~~- i.e., b - laststart.~~

~~- We insert this at the beginning of the loop~~

~~- so that if we fail during matching, we'll~~

~~- reinitialize the bounds. */~~

~~- insert_op2 (set_number_at, laststart, b - laststart,~~

~~- upper_bound - 1, b);~~

~~- b += 5;~~

~~- }~~

~~- pending_exact = 0;~~

~~- beg_interval = NULL;~~

~~- }~~

~~- break;~~

~~- unfetch_interval:~~

~~- /* If an invalid interval, match the characters as literals. */~~

~~- assert (beg_interval);~~

~~- p = beg_interval;~~

~~- beg_interval = NULL;~~

~~- /* normal_char and normal_backslash need `c'. */~~

~~- PATFETCH (c);~~

~~- if (!(syntax & RE_NO_BK_BRACES))~~

~~- {~~

~~- if (p > pattern && p[-1] == '\\')~~

~~- goto normal_backslash;~~

~~- }~~

~~- goto normal_char;~~

~~-#ifdef emacs~~

~~- /* There is no way to specify the before_dot and after_dot~~

~~- operators. rms says this is ok. --karl */~~

~~- case '=':~~

~~- BUF_PUSH (at_dot);~~

~~- break;~~

~~- case 's':~~

~~- laststart = b;~~

~~- PATFETCH (c);~~

~~- BUF_PUSH_2 (syntaxspec, syntax_spec_code[c]);~~

~~- break;~~

~~- case 'S':~~

~~- laststart = b;~~

~~- PATFETCH (c);~~

~~- BUF_PUSH_2 (notsyntaxspec, syntax_spec_code[c]);~~

~~- break;~~

~~-#endif /* emacs */~~

~~- case 'w':~~

~~- laststart = b;~~

~~- BUF_PUSH (wordchar);~~

~~- break;~~

~~- case 'W':~~

~~- laststart = b;~~

~~- BUF_PUSH (notwordchar);~~

~~- break;~~

~~- case '<':~~

~~- BUF_PUSH (wordbeg);~~

~~- break;~~

~~- case '>':~~

~~- BUF_PUSH (wordend);~~

~~- break;~~

~~- case 'b':~~

~~- BUF_PUSH (wordbound);~~

~~- break;~~

~~- case 'B':~~

~~- BUF_PUSH (notwordbound);~~

~~- break;~~

~~- case '`':~~

~~- BUF_PUSH (begbuf);~~

~~- break;~~

~~- case '\'':~~

~~- BUF_PUSH (endbuf);~~

~~- break;~~

~~- case '1': case '2': case '3': case '4': case '5':~~

~~- case '6': case '7': case '8': case '9':~~

~~- if (syntax & RE_NO_BK_REFS)~~

~~- goto normal_char;~~

~~- c1 = c - '0';~~

~~- if (c1 > regnum)~~

~~- return REG_ESUBREG;~~

~~- /* Can't back reference to a subexpression if inside of it. */~~

~~- if (group_in_compile_stack (compile_stack, c1))~~

~~- goto normal_char;~~

~~- laststart = b;~~

~~- BUF_PUSH_2 (duplicate, c1);~~

~~- break;~~

~~- case '+':~~

~~- case '?':~~

~~- if (syntax & RE_BK_PLUS_QM)~~

~~- goto handle_plus;~~

~~- else~~

~~- goto normal_backslash;~~

~~- default:~~

~~- normal_backslash:~~

~~- /* You might think it would be useful for \ to mean~~

~~- not to translate; but if we don't translate it~~

~~- it will never match anything. */~~

~~- c = TRANSLATE (c);~~

~~- goto normal_char;~~

~~- }~~

~~- break;~~

~~- default:~~

~~- /* Expects the character in `c'. */~~

~~- normal_char:~~

~~- /* If no exactn currently being built. */~~

~~- if (!pending_exact~~

~~- /* If last exactn not at current position. */~~

~~- || pending_exact + *pending_exact + 1 != b~~

~~- /* We have only one byte following the exactn for the count. */~~

~~- || *pending_exact == (1 << BYTEWIDTH) - 1~~

~~- /* If followed by a repetition operator. */~~

~~- || *p == '*' || *p == '^'~~

~~- || ((syntax & RE_BK_PLUS_QM)~~

~~- ? *p == '\\' && (p[1] == '+' || p[1] == '?')~~

~~- : (*p == '+' || *p == '?'))~~

~~- || ((syntax & RE_INTERVALS)~~

~~- && ((syntax & RE_NO_BK_BRACES)~~

~~- ? *p == '{'~~

~~- : (p[0] == '\\' && p[1] == '{'))))~~

~~- {~~

~~- /* Start building a new exactn. */~~

~~- laststart = b;~~

~~- BUF_PUSH_2 (exactn, 0);~~

~~- pending_exact = b - 1;~~

~~- }~~

~~- BUF_PUSH (c);~~

~~- (*pending_exact)++;~~

~~- break;~~

~~- } /* switch (c) */~~

~~- } /* while p != pend */~~

~~- /* Through the pattern now. */~~

~~- if (fixup_alt_jump)~~

~~- STORE_JUMP (jump_past_alt, fixup_alt_jump, b);~~

~~- if (!COMPILE_STACK_EMPTY)~~

~~- return REG_EPAREN;~~

~~- free (compile_stack.stack);~~

~~- /* We have succeeded; set the length of the buffer. */~~

~~- bufp->used = b - bufp->buffer;~~

~~-#ifdef DEBUG~~

~~- if (debug)~~

~~- {~~

~~- DEBUG_PRINT1 ("\nCompiled pattern: ");~~

~~- print_compiled_pattern (bufp);~~

~~- }~~

~~-#endif /* DEBUG */~~

~~- return REG_NOERROR;~~

~~-} /* regex_compile */~~

~~-/* Subroutines for `regex_compile'. */~~

~~-/* Store OP at LOC followed by two-byte integer parameter ARG. */~~

~~-static void~~

~~-store_op1 (op, loc, arg)~~

~~- re_opcode_t op;~~

~~- unsigned char *loc;~~

~~- int arg;~~

~~- *loc = (unsigned char) op;~~

~~- STORE_NUMBER (loc + 1, arg);~~

~~-/* Like `store_op1', but for two two-byte parameters ARG1 and ARG2. */~~

~~-static void~~

~~-store_op2 (op, loc, arg1, arg2)~~

~~- re_opcode_t op;~~

~~- unsigned char *loc;~~

~~- int arg1, arg2;~~

~~- *loc = (unsigned char) op;~~

~~- STORE_NUMBER (loc + 1, arg1);~~

~~- STORE_NUMBER (loc + 3, arg2);~~

~~-/* Copy the bytes from LOC to END to open up three bytes of space at LOC~~

~~- for OP followed by two-byte integer parameter ARG. */~~

~~-static void~~

~~-insert_op1 (op, loc, arg, end)~~

~~- re_opcode_t op;~~

~~- unsigned char *loc;~~

~~- int arg;~~

~~- unsigned char *end;~~

~~- register unsigned char *pfrom = end;~~

~~- register unsigned char *pto = end + 3;~~

~~- while (pfrom != loc)~~

~~- *--pto = *--pfrom;~~

~~- store_op1 (op, loc, arg);~~

~~-/* Like `insert_op1', but for two two-byte parameters ARG1 and ARG2. */~~

~~-static void~~

~~-insert_op2 (op, loc, arg1, arg2, end)~~

~~- re_opcode_t op;~~

~~- unsigned char *loc;~~

~~- int arg1, arg2;~~

~~- unsigned char *end;~~

~~- register unsigned char *pfrom = end;~~

~~- register unsigned char *pto = end + 5;~~

~~- while (pfrom != loc)~~

~~- *--pto = *--pfrom;~~

~~- store_op2 (op, loc, arg1, arg2);~~

~~-/* P points to just after a ^ in PATTERN. Return true if that ^ comes~~

~~- after an alternative or a begin-subexpression. We assume there is at~~

~~- least one character before the ^. */~~

~~-static boolean~~

~~-at_begline_loc_p (pattern, p, syntax)~~

~~- const char *pattern, *p;~~

~~- reg_syntax_t syntax;~~

~~- const char *prev = p - 2;~~

~~- boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\';~~

~~- return~~

~~- /* After a subexpression? */~~

~~- (*prev == '(' && (syntax & RE_NO_BK_PARENS || prev_prev_backslash))~~

~~- /* After an alternative? */~~

~~- || (*prev == '|' && (syntax & RE_NO_BK_VBAR || prev_prev_backslash));~~

~~-/* The dual of at_begline_loc_p. This one is for $. We assume there is~~

~~- at least one character after the $, i.e., `P < PEND'. */~~

~~-static boolean~~

~~-at_endline_loc_p (p, pend, syntax)~~

~~- const char *p, *pend;~~

~~- int syntax;~~

~~- const char *next = p;~~

~~- boolean next_backslash = *next == '\\';~~

~~- const char *next_next = p + 1 < pend ? p + 1 : NULL;~~

~~- return~~

~~- /* Before a subexpression? */~~

~~- (syntax & RE_NO_BK_PARENS ? *next == ')'~~

~~- : next_backslash && next_next && *next_next == ')')~~

~~- /* Before an alternative? */~~

~~- || (syntax & RE_NO_BK_VBAR ? *next == '|'~~

~~- : next_backslash && next_next && *next_next == '|');~~

~~-/* Returns true if REGNUM is in one of COMPILE_STACK's elements and~~

~~- false if it's not. */~~

~~-static boolean~~

~~-group_in_compile_stack (compile_stack, regnum)~~

~~- compile_stack_type compile_stack;~~

~~- regnum_t regnum;~~

~~- int this_element;~~

~~- for (this_element = compile_stack.avail - 1;~~

~~- this_element >= 0;~~

~~- this_element--)~~

~~- if (compile_stack.stack[this_element].regnum == regnum)~~

~~- return true;~~

~~- return false;~~

~~-/* Read the ending character of a range (in a bracket expression) from the~~

~~- uncompiled pattern *P_PTR (which ends at PEND). We assume the~~

~~- starting character is in `P[-2]'. (`P[-1]' is the character `-'.)~~

~~- Then we set the translation of all bits between the starting and~~

~~- ending characters (inclusive) in the compiled pattern B.~~

~~- Return an error code.~~

~~- We use these short variable names so we can use the same macros as~~

~~- `regex_compile' itself. */~~

~~-static reg_errcode_t~~

~~-compile_range (p_ptr, pend, translate, syntax, b)~~

~~- const char **p_ptr, *pend;~~

~~- char *translate;~~

~~- reg_syntax_t syntax;~~

~~- unsigned char *b;~~

~~- unsigned this_char;~~

~~- const char *p = *p_ptr;~~

~~- int range_start, range_end;~~

~~- if (p == pend)~~

~~- return REG_ERANGE;~~

~~- /* Even though the pattern is a signed `char *', we need to fetch~~

~~- with unsigned char *'s; if the high bit of the pattern character~~

~~- is set, the range endpoints will be negative if we fetch using a~~

~~- signed char *.~~

~~- We also want to fetch the endpoints without translating them; the~~

~~- appropriate translation is done in the bit-setting loop below. */~~

~~- range_start = ((unsigned char *) p)[-2];~~

~~- range_end = ((unsigned char *) p)[0];~~

~~- /* Have to increment the pointer into the pattern string, so the~~

~~- caller isn't still at the ending character. */~~

~~- (*p_ptr)++;~~

~~- /* If the start is after the end, the range is empty. */~~

~~- if (range_start > range_end)~~

~~- return syntax & RE_NO_EMPTY_RANGES ? REG_ERANGE : REG_NOERROR;~~

~~- /* Here we see why `this_char' has to be larger than an `unsigned~~

~~- char' -- the range is inclusive, so if `range_end' == 0xff~~

~~- (assuming 8-bit characters), we would otherwise go into an infinite~~

~~- loop, since all characters <= 0xff. */~~

~~- for (this_char = range_start; this_char <= range_end; this_char++)~~

~~- {~~

~~- SET_LIST_BIT (TRANSLATE (this_char));~~

~~- }~~

~~- return REG_NOERROR;~~

~~-/* Failure stack declarations and macros; both re_compile_fastmap and~~

~~- re_match_2 use a failure stack. These have to be macros because of~~

~~- REGEX_ALLOCATE. */~~

~~-/* Number of failure points for which to initially allocate space~~

~~- when matching. If this number is exceeded, we allocate more~~

~~- space, so it is not a hard limit. */~~

~~-#ifndef INIT_FAILURE_ALLOC~~

~~-#define INIT_FAILURE_ALLOC 5~~

~~-#endif~~

~~-/* Roughly the maximum number of failure points on the stack. Would be~~

~~- exactly that if always used MAX_FAILURE_SPACE each time we failed.~~

~~- This is a variable only so users of regex can assign to it; we never~~

~~- change it ourselves. */~~

~~-int re_max_failures = 2000;~~

~~-typedef const unsigned char *fail_stack_elt_t;~~

~~-typedef struct~~

~~- fail_stack_elt_t *stack;~~

~~- unsigned size;~~

~~- unsigned avail; /* Offset of next open position. */~~

~~-} fail_stack_type;~~

~~-#define FAIL_STACK_EMPTY() (fail_stack.avail == 0)~~

~~-#define FAIL_STACK_PTR_EMPTY() (fail_stack_ptr->avail == 0)~~

~~-#define FAIL_STACK_FULL() (fail_stack.avail == fail_stack.size)~~

~~-#define FAIL_STACK_TOP() (fail_stack.stack[fail_stack.avail])~~

~~-/* Initialize `fail_stack'. Do `return -2' if the alloc fails. */~~

~~-#define INIT_FAIL_STACK() \~~

~~- do { \~~

~~- fail_stack.stack = (fail_stack_elt_t *) \~~

~~- REGEX_ALLOCATE (INIT_FAILURE_ALLOC * sizeof (fail_stack_elt_t)); \~~

~~- \~~

~~- if (fail_stack.stack == NULL) \~~

~~- return -2; \~~

~~- \~~

~~- fail_stack.size = INIT_FAILURE_ALLOC; \~~

~~- fail_stack.avail = 0; \~~

~~- } while (0)~~

~~-/* Double the size of FAIL_STACK, up to approximately `re_max_failures' items.~~

~~- Return 1 if succeeds, and 0 if either ran out of memory~~

~~- allocating space for it or it was already too large.~~

~~- REGEX_REALLOCATE requires `destination' be declared. */~~

~~-#define DOUBLE_FAIL_STACK(fail_stack) \~~

~~- ((fail_stack).size > re_max_failures * MAX_FAILURE_ITEMS \~~

~~- ? 0 \~~

~~- : ((fail_stack).stack = (fail_stack_elt_t *) \~~

~~- REGEX_REALLOCATE ((fail_stack).stack, \~~

~~- (fail_stack).size * sizeof (fail_stack_elt_t), \~~

~~- ((fail_stack).size << 1) * sizeof (fail_stack_elt_t)), \~~

~~- \~~

~~- (fail_stack).stack == NULL \~~

~~- ? 0 \~~

~~- : ((fail_stack).size <<= 1, \~~

~~- 1)))~~

~~-/* Push PATTERN_OP on FAIL_STACK.~~

~~- Return 1 if was able to do so and 0 if ran out of memory allocating~~

~~- space to do so. */~~

~~-#define PUSH_PATTERN_OP(pattern_op, fail_stack) \~~

~~- ((FAIL_STACK_FULL () \~~

~~- && !DOUBLE_FAIL_STACK (fail_stack)) \~~

~~- ? 0 \~~

~~- : ((fail_stack).stack[(fail_stack).avail++] = pattern_op, \~~

~~- 1))~~

~~-/* This pushes an item onto the failure stack. Must be a four-byte~~

~~- value. Assumes the variable `fail_stack'. Probably should only~~

~~- be called from within `PUSH_FAILURE_POINT'. */~~

~~-#define PUSH_FAILURE_ITEM(item) \~~

~~- fail_stack.stack[fail_stack.avail++] = (fail_stack_elt_t) item~~

~~-/* The complement operation. Assumes `fail_stack' is nonempty. */~~

~~-#define POP_FAILURE_ITEM() fail_stack.stack[--fail_stack.avail]~~

~~-/* Used to omit pushing failure point id's when we're not debugging. */~~

~~-#ifdef DEBUG~~

~~-#define DEBUG_PUSH PUSH_FAILURE_ITEM~~

~~-#define DEBUG_POP(item_addr) *(item_addr) = POP_FAILURE_ITEM ()~~

~~-#else~~

~~-#define DEBUG_PUSH(item)~~

~~-#define DEBUG_POP(item_addr)~~

~~-#endif~~

~~-/* Push the information about the state we will need~~

~~- if we ever fail back to it.~~

~~- Requires variables fail_stack, regstart, regend, reg_info, and~~

~~- num_regs be declared. DOUBLE_FAIL_STACK requires `destination' be~~

~~- declared.~~

~~- Does `return FAILURE_CODE' if runs out of memory. */~~

~~-#define PUSH_FAILURE_POINT(pattern_place, string_place, failure_code) \~~

~~- do { \~~

~~- char *destination; \~~

~~- /* Must be int, so when we don't save any registers, the arithmetic \~~

~~- of 0 + -1 isn't done as unsigned. */ \~~

~~- int this_reg; \~~

~~- \~~

~~- DEBUG_STATEMENT (failure_id++); \~~

~~- DEBUG_STATEMENT (nfailure_points_pushed++); \~~

~~- DEBUG_PRINT2 ("\nPUSH_FAILURE_POINT #%u:\n", failure_id); \~~

~~- DEBUG_PRINT2 (" Before push, next avail: %d\n", (fail_stack).avail);\~~

~~- DEBUG_PRINT2 (" size: %d\n", (fail_stack).size);\~~

~~- \~~

~~- DEBUG_PRINT2 (" slots needed: %d\n", NUM_FAILURE_ITEMS); \~~

~~- DEBUG_PRINT2 (" available: %d\n", REMAINING_AVAIL_SLOTS); \~~

~~- \~~

~~- /* Ensure we have enough space allocated for what we will push. */ \~~

~~- while (REMAINING_AVAIL_SLOTS < NUM_FAILURE_ITEMS) \~~

~~- { \~~

~~- if (!DOUBLE_FAIL_STACK (fail_stack)) \~~

~~- return failure_code; \~~

~~- \~~

~~- DEBUG_PRINT2 ("\n Doubled stack; size now: %d\n", \~~

~~- (fail_stack).size); \~~

~~- DEBUG_PRINT2 (" slots available: %d\n", REMAINING_AVAIL_SLOTS);\~~

~~- } \~~

~~- \~~

~~- /* Push the info, starting with the registers. */ \~~

~~- DEBUG_PRINT1 ("\n"); \~~

~~- \~~

~~- for (this_reg = lowest_active_reg; this_reg <= highest_active_reg; \~~

~~- this_reg++) \~~

~~- { \~~

~~- DEBUG_PRINT2 (" Pushing reg: %d\n", this_reg); \~~

~~- DEBUG_STATEMENT (num_regs_pushed++); \~~

~~- \~~

~~- DEBUG_PRINT2 (" start: 0x%x\n", regstart[this_reg]); \~~

~~- PUSH_FAILURE_ITEM (regstart[this_reg]); \~~

~~- \~~

~~- DEBUG_PRINT2 (" end: 0x%x\n", regend[this_reg]); \~~

~~- PUSH_FAILURE_ITEM (regend[this_reg]); \~~

~~- \~~

~~- DEBUG_PRINT2 (" info: 0x%x\n ", reg_info[this_reg]); \~~

~~- DEBUG_PRINT2 (" match_null=%d", \~~

~~- REG_MATCH_NULL_STRING_P (reg_info[this_reg])); \~~

~~- DEBUG_PRINT2 (" active=%d", IS_ACTIVE (reg_info[this_reg])); \~~

~~- DEBUG_PRINT2 (" matched_something=%d", \~~

~~- MATCHED_SOMETHING (reg_info[this_reg])); \~~

~~- DEBUG_PRINT2 (" ever_matched=%d", \~~

~~- EVER_MATCHED_SOMETHING (reg_info[this_reg])); \~~

~~- DEBUG_PRINT1 ("\n"); \~~

~~- PUSH_FAILURE_ITEM (reg_info[this_reg].word); \~~

~~- } \~~

~~- \~~

~~- DEBUG_PRINT2 (" Pushing low active reg: %d\n", lowest_active_reg);\~~

~~- PUSH_FAILURE_ITEM (lowest_active_reg); \~~

~~- \~~

~~- DEBUG_PRINT2 (" Pushing high active reg: %d\n", highest_active_reg);\~~

~~- PUSH_FAILURE_ITEM (highest_active_reg); \~~

~~- \~~

~~- DEBUG_PRINT2 (" Pushing pattern 0x%x: ", pattern_place); \~~

~~- DEBUG_PRINT_COMPILED_PATTERN (bufp, pattern_place, pend); \~~

~~- PUSH_FAILURE_ITEM (pattern_place); \~~

~~- \~~

~~- DEBUG_PRINT2 (" Pushing string 0x%x: `", string_place); \~~

~~- DEBUG_PRINT_DOUBLE_STRING (string_place, string1, size1, string2, \~~

~~- size2); \~~

~~- DEBUG_PRINT1 ("'\n"); \~~

~~- PUSH_FAILURE_ITEM (string_place); \~~

~~- \~~

~~- DEBUG_PRINT2 (" Pushing failure id: %u\n", failure_id); \~~

~~- DEBUG_PUSH (failure_id); \~~

~~- } while (0)~~

~~-/* This is the number of items that are pushed and popped on the stack~~

~~- for each register. */~~

~~-#define NUM_REG_ITEMS 3~~

~~-/* Individual items aside from the registers. */~~

~~-#ifdef DEBUG~~

~~-#define NUM_NONREG_ITEMS 5 /* Includes failure point id. */~~

~~-#else~~

~~-#define NUM_NONREG_ITEMS 4~~

~~-#endif~~

~~-/* We push at most this many items on the stack. */~~

~~-#define MAX_FAILURE_ITEMS ((num_regs - 1) * NUM_REG_ITEMS + NUM_NONREG_ITEMS)~~

~~-/* We actually push this many items. */~~

~~-#define NUM_FAILURE_ITEMS \~~

~~- ((highest_active_reg - lowest_active_reg + 1) * NUM_REG_ITEMS \~~

~~- + NUM_NONREG_ITEMS)~~

~~-/* How many items can still be added to the stack without overflowing it. */~~

~~-#define REMAINING_AVAIL_SLOTS ((fail_stack).size - (fail_stack).avail)~~

~~-/* Pops what PUSH_FAIL_STACK pushes.~~

~~- We restore into the parameters, all of which should be lvalues:~~

~~- STR -- the saved data position.~~

~~- PAT -- the saved pattern position.~~

~~- LOW_REG, HIGH_REG -- the highest and lowest active registers.~~

~~- REGSTART, REGEND -- arrays of string positions.~~

~~- REG_INFO -- array of information about each subexpression.~~

~~- Also assumes the variables `fail_stack' and (if debugging), `bufp',~~

~~- `pend', `string1', `size1', `string2', and `size2'. */~~

~~-#define POP_FAILURE_POINT(str, pat, low_reg, high_reg, regstart, regend, reg_info)\~~

~~-{ \~~

~~- DEBUG_STATEMENT (fail_stack_elt_t failure_id;) \~~

~~- int this_reg; \~~

~~- const unsigned char *string_temp; \~~

~~- \~~

~~- assert (!FAIL_STACK_EMPTY ()); \~~

~~- \~~

~~- /* Remove failure points and point to how many regs pushed. */ \~~

~~- DEBUG_PRINT1 ("POP_FAILURE_POINT:\n"); \~~

~~- DEBUG_PRINT2 (" Before pop, next avail: %d\n", fail_stack.avail); \~~

~~- DEBUG_PRINT2 (" size: %d\n", fail_stack.size); \~~

~~- \~~

~~- assert (fail_stack.avail >= NUM_NONREG_ITEMS); \~~

~~- \~~

~~- DEBUG_POP (&failure_id); \~~

~~- DEBUG_PRINT2 (" Popping failure id: %u\n", failure_id); \~~

~~- \~~

~~- /* If the saved string location is NULL, it came from an \~~

~~- on_failure_keep_string_jump opcode, and we want to throw away the \~~

~~- saved NULL, thus retaining our current position in the string. */ \~~

~~- string_temp = POP_FAILURE_ITEM (); \~~

~~- if (string_temp != NULL) \~~

~~- str = (const char *) string_temp; \~~

~~- \~~

~~- DEBUG_PRINT2 (" Popping string 0x%x: `", str); \~~

~~- DEBUG_PRINT_DOUBLE_STRING (str, string1, size1, string2, size2); \~~

~~- DEBUG_PRINT1 ("'\n"); \~~

~~- \~~

~~- pat = (unsigned char *) POP_FAILURE_ITEM (); \~~

~~- DEBUG_PRINT2 (" Popping pattern 0x%x: ", pat); \~~

~~- DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend); \~~

~~- \~~

~~- /* Restore register info. */ \~~

~~- high_reg = (unsigned) POP_FAILURE_ITEM (); \~~

~~- DEBUG_PRINT2 (" Popping high active reg: %d\n", high_reg); \~~

~~- \~~

~~- low_reg = (unsigned) POP_FAILURE_ITEM (); \~~

~~- DEBUG_PRINT2 (" Popping low active reg: %d\n", low_reg); \~~

~~- \~~

~~- for (this_reg = high_reg; this_reg >= low_reg; this_reg--) \~~

~~- { \~~

~~- DEBUG_PRINT2 (" Popping reg: %d\n", this_reg); \~~

~~- \~~

~~- reg_info[this_reg].word = POP_FAILURE_ITEM (); \~~

~~- DEBUG_PRINT2 (" info: 0x%x\n", reg_info[this_reg]); \~~

~~- \~~

~~- regend[this_reg] = (const char *) POP_FAILURE_ITEM (); \~~

~~- DEBUG_PRINT2 (" end: 0x%x\n", regend[this_reg]); \~~

~~- \~~

~~- regstart[this_reg] = (const char *) POP_FAILURE_ITEM (); \~~

~~- DEBUG_PRINT2 (" start: 0x%x\n", regstart[this_reg]); \~~

~~- } \~~

~~- \~~

~~- DEBUG_STATEMENT (nfailure_points_popped++); \~~

~~-} /* POP_FAILURE_POINT */~~

~~-/* re_compile_fastmap computes a ``fastmap'' for the compiled pattern in~~

~~- BUFP. A fastmap records which of the (1 << BYTEWIDTH) possible~~

~~- characters can start a string that matches the pattern. This fastmap~~

~~- is used by re_search to skip quickly over impossible starting points.~~

~~- The caller must supply the address of a (1 << BYTEWIDTH)-byte data~~

~~- area as BUFP->fastmap.~~

~~- We set the `fastmap', `fastmap_accurate', and `can_be_null' fields in~~

~~- the pattern buffer.~~

~~- Returns 0 if we succeed, -2 if an internal error. */~~

~~-int~~

~~-re_compile_fastmap (bufp)~~

~~- struct re_pattern_buffer *bufp;~~

~~- int j, k;~~

~~- fail_stack_type fail_stack;~~

~~-#ifndef REGEX_MALLOC~~

~~- char *destination;~~

~~-#endif~~

~~- /* We don't push any register information onto the failure stack. */~~

~~- unsigned num_regs = 0;~~

~~- register char *fastmap = bufp->fastmap;~~

~~- unsigned char *pattern = bufp->buffer;~~

~~- unsigned long size = bufp->used;~~

~~- const unsigned char *p = pattern;~~

~~- register unsigned char *pend = pattern + size;~~

~~- /* Assume that each path through the pattern can be null until~~

~~- proven otherwise. We set this false at the bottom of switch~~

~~- statement, to which we get only if a particular path doesn't~~

~~- match the empty string. */~~

~~- boolean path_can_be_null = true;~~

~~- /* We aren't doing a `succeed_n' to begin with. */~~

~~- boolean succeed_n_p = false;~~

~~- assert (fastmap != NULL && p != NULL);~~

~~- INIT_FAIL_STACK ();~~

~~- bzero (fastmap, 1 << BYTEWIDTH); /* Assume nothing's valid. */~~

~~- bufp->fastmap_accurate = 1; /* It will be when we're done. */~~

~~- bufp->can_be_null = 0;~~

~~- while (p != pend || !FAIL_STACK_EMPTY ())~~

~~- {~~

~~- if (p == pend)~~

~~- {~~

~~- bufp->can_be_null |= path_can_be_null;~~

~~- /* Reset for next path. */~~

~~- path_can_be_null = true;~~

~~- p = fail_stack.stack[--fail_stack.avail];~~

~~- }~~

~~- /* We should never be about to go beyond the end of the pattern. */~~

~~- assert (p < pend);~~

~~-#ifdef SWITCH_ENUM_BUG~~

~~- switch ((int) ((re_opcode_t) *p++))~~

~~-#else~~

~~- switch ((re_opcode_t) *p++)~~

~~-#endif~~

~~- {~~

~~- /* I guess the idea here is to simply not bother with a fastmap~~

~~- if a backreference is used, since it's too hard to figure out~~

~~- the fastmap for the corresponding group. Setting~~

~~- `can_be_null' stops `re_search_2' from using the fastmap, so~~

~~- that is all we do. */~~

~~- case duplicate:~~

~~- bufp->can_be_null = 1;~~

~~- return 0;~~

~~- /* Following are the cases which match a character. These end~~

~~- with `break'. */~~

~~- case exactn:~~

~~- fastmap[p[1]] = 1;~~

~~- break;~~

~~- case charset:~~

~~- for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--)~~

~~- if (p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH)))~~

~~- fastmap[j] = 1;~~

~~- break;~~

~~- case charset_not:~~

~~- /* Chars beyond end of map must be allowed. */~~

~~- for (j = *p * BYTEWIDTH; j < (1 << BYTEWIDTH); j++)~~

~~- fastmap[j] = 1;~~

~~- for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--)~~

~~- if (!(p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH))))~~

~~- fastmap[j] = 1;~~

~~- break;~~

~~- case wordchar:~~

~~- for (j = 0; j < (1 << BYTEWIDTH); j++)~~

~~- if (SYNTAX (j) == Sword)~~

~~- fastmap[j] = 1;~~

~~- break;~~

~~- case notwordchar:~~

~~- for (j = 0; j < (1 << BYTEWIDTH); j++)~~

~~- if (SYNTAX (j) != Sword)~~

~~- fastmap[j] = 1;~~

~~- break;~~

~~- case anychar:~~

~~- /* `.' matches anything ... */~~

~~- for (j = 0; j < (1 << BYTEWIDTH); j++)~~

~~- fastmap[j] = 1;~~

~~- /* ... except perhaps newline. */~~

~~- if (!(bufp->syntax & RE_DOT_NEWLINE))~~

~~- fastmap['\n'] = 0;~~

~~- /* Return if we have already set `can_be_null'; if we have,~~

~~- then the fastmap is irrelevant. Something's wrong here. */~~

~~- else if (bufp->can_be_null)~~

~~- return 0;~~

~~- /* Otherwise, have to check alternative paths. */~~

~~- break;~~

~~-#ifdef emacs~~

~~- case syntaxspec:~~

~~- k = *p++;~~

~~- for (j = 0; j < (1 << BYTEWIDTH); j++)~~

~~- if (SYNTAX (j) == (enum syntaxcode) k)~~

~~- fastmap[j] = 1;~~

~~- break;~~

~~- case notsyntaxspec:~~

~~- k = *p++;~~

~~- for (j = 0; j < (1 << BYTEWIDTH); j++)~~

~~- if (SYNTAX (j) != (enum syntaxcode) k)~~

~~- fastmap[j] = 1;~~

~~- break;~~

~~- /* All cases after this match the empty string. These end with~~

~~- `continue'. */~~

~~- case before_dot:~~

~~- case at_dot:~~

~~- case after_dot:~~

~~- continue;~~

~~-#endif /* not emacs */~~

~~- case no_op:~~

~~- case begline:~~

~~- case endline:~~

~~- case begbuf:~~

~~- case endbuf:~~

~~- case wordbound:~~

~~- case notwordbound:~~

~~- case wordbeg:~~

~~- case wordend:~~

~~- case push_dummy_failure:~~

~~- continue;~~

~~- case jump_n:~~

~~- case pop_failure_jump:~~

~~- case maybe_pop_jump:~~

~~- case jump:~~

~~- case jump_past_alt:~~

~~- case dummy_failure_jump:~~

~~- EXTRACT_NUMBER_AND_INCR (j, p);~~

~~- p += j;~~

~~- if (j > 0)~~

~~- continue;~~

~~- /* Jump backward implies we just went through the body of a~~

~~- loop and matched nothing. Opcode jumped to should be~~

~~- `on_failure_jump' or `succeed_n'. Just treat it like an~~

~~- ordinary jump. For a * loop, it has pushed its failure~~

~~- point already; if so, discard that as redundant. */~~

~~- if ((re_opcode_t) *p != on_failure_jump~~

~~- && (re_opcode_t) *p != succeed_n)~~

~~- continue;~~

~~- p++;~~

~~- EXTRACT_NUMBER_AND_INCR (j, p);~~

~~- p += j;~~

~~- /* If what's on the stack is where we are now, pop it. */~~

~~- if (!FAIL_STACK_EMPTY ()~~

~~- && fail_stack.stack[fail_stack.avail - 1] == p)~~

~~- fail_stack.avail--;~~

~~- continue;~~

~~- case on_failure_jump:~~

~~- case on_failure_keep_string_jump:~~

~~- handle_on_failure_jump:~~

~~- EXTRACT_NUMBER_AND_INCR (j, p);~~

~~- /* For some patterns, e.g., `(a?)?', `p+j' here points to the~~

~~- end of the pattern. We don't want to push such a point,~~

~~- since when we restore it above, entering the switch will~~

~~- increment `p' past the end of the pattern. We don't need~~

~~- to push such a point since we obviously won't find any more~~

~~- fastmap entries beyond `pend'. Such a pattern can match~~

~~- the null string, though. */~~

~~- if (p + j < pend)~~

~~- {~~

~~- if (!PUSH_PATTERN_OP (p + j, fail_stack))~~

~~- return -2;~~

~~- }~~

~~- else~~

~~- bufp->can_be_null = 1;~~

~~- if (succeed_n_p)~~

~~- {~~

~~- EXTRACT_NUMBER_AND_INCR (k, p); /* Skip the n. */~~

~~- succeed_n_p = false;~~

~~- }~~

~~- continue;~~

~~- case succeed_n:~~

~~- /* Get to the number of times to succeed. */~~

~~- p += 2;~~

~~- /* Increment p past the n for when k != 0. */~~

~~- EXTRACT_NUMBER_AND_INCR (k, p);~~

~~- if (k == 0)~~

~~- {~~

~~- p -= 4;~~

~~- succeed_n_p = true; /* Spaghetti code alert. */~~

~~- goto handle_on_failure_jump;~~

~~- }~~

~~- continue;~~

~~- case set_number_at:~~

~~- p += 4;~~

~~- continue;~~

~~- case start_memory:~~

~~- case stop_memory:~~

~~- p += 2;~~

~~- continue;~~

~~- default:~~

~~- abort (); /* We have listed all the cases. */~~

~~- } /* switch *p++ */~~

~~- /* Getting here means we have found the possible starting~~

~~- characters for one path of the pattern -- and that the empty~~

~~- string does not match. We need not follow this path further.~~

~~- Instead, look at the next alternative (remembered on the~~

~~- stack), or quit if no more. The test at the top of the loop~~

~~- does these things. */~~

~~- path_can_be_null = false;~~

~~- p = pend;~~

~~- } /* while p */~~

~~- /* Set `can_be_null' for the last path (also the first path, if the~~

~~- pattern is empty). */~~

~~- bufp->can_be_null |= path_can_be_null;~~

~~- return 0;~~

~~-} /* re_compile_fastmap */~~

~~-/* Set REGS to hold NUM_REGS registers, storing them in STARTS and~~

~~- ENDS. Subsequent matches using PATTERN_BUFFER and REGS will use~~

~~- this memory for recording register information. STARTS and ENDS~~

~~- must be allocated using the malloc library routine, and must each~~

~~- be at least NUM_REGS * sizeof (regoff_t) bytes long.~~

~~- If NUM_REGS == 0, then subsequent matches should allocate their own~~

~~- register data.~~

~~- Unless this function is called, the first search or match using~~

~~- PATTERN_BUFFER will allocate its own register data, without~~

~~- freeing the old data. */~~

~~-void~~

~~-re_set_registers (bufp, regs, num_regs, starts, ends)~~

~~- struct re_pattern_buffer *bufp;~~

~~- struct re_registers *regs;~~

~~- unsigned num_regs;~~

~~- regoff_t *starts, *ends;~~

~~- if (num_regs)~~

~~- {~~

~~- bufp->regs_allocated = REGS_REALLOCATE;~~

~~- regs->num_regs = num_regs;~~

~~- regs->start = starts;~~

~~- regs->end = ends;~~

~~- }~~

~~- else~~

~~- {~~

~~- bufp->regs_allocated = REGS_UNALLOCATED;~~

~~- regs->num_regs = 0;~~

~~- regs->start = regs->end = (regoff_t) 0;~~

~~- }~~

~~-/* Searching routines. */~~

~~-/* Like re_search_2, below, but only one string is specified, and~~

~~- doesn't let you say where to stop matching. */~~

~~-int~~

~~-re_search (bufp, string, size, startpos, range, regs)~~

~~- struct re_pattern_buffer *bufp;~~

~~- const char *string;~~

~~- int size, startpos, range;~~

~~- struct re_registers *regs;~~

~~- return re_search_2 (bufp, NULL, 0, string, size, startpos, range,~~

~~- regs, size);~~

~~-/* Using the compiled pattern in BUFP->buffer, first tries to match the~~

~~- virtual concatenation of STRING1 and STRING2, starting first at index~~

~~- STARTPOS, then at STARTPOS + 1, and so on.~~

~~- STRING1 and STRING2 have length SIZE1 and SIZE2, respectively.~~

~~- RANGE is how far to scan while trying to match. RANGE = 0 means try~~

~~- only at STARTPOS; in general, the last start tried is STARTPOS +~~

~~- RANGE.~~

~~- In REGS, return the indices of the virtual concatenation of STRING1~~

~~- and STRING2 that matched the entire BUFP->buffer and its contained~~

~~- subexpressions.~~

~~- Do not consider matching one past the index STOP in the virtual~~

~~- concatenation of STRING1 and STRING2.~~

~~- We return either the position in the strings at which the match was~~

~~- found, -1 if no match, or -2 if error (such as failure~~

~~- stack overflow). */~~

~~-int~~

~~-re_search_2 (bufp, string1, size1, string2, size2, startpos, range, regs, stop)~~

~~- struct re_pattern_buffer *bufp;~~

~~- const char *string1, *string2;~~

~~- int size1, size2;~~

~~- int startpos;~~

~~- int range;~~

~~- struct re_registers *regs;~~

~~- int stop;~~

~~- int val;~~

~~- register char *fastmap = bufp->fastmap;~~

~~- register char *translate = bufp->translate;~~

~~- int total_size = size1 + size2;~~

~~- int endpos = startpos + range;~~

~~- /* Check for out-of-range STARTPOS. */~~

~~- if (startpos < 0 || startpos > total_size)~~

~~- return -1;~~

~~- /* Fix up RANGE if it might eventually take us outside~~

~~- the virtual concatenation of STRING1 and STRING2. */~~

~~- if (endpos < -1)~~

~~- range = -1 - startpos;~~

~~- else if (endpos > total_size)~~

~~- range = total_size - startpos;~~

~~- /* If the search isn't to be a backwards one, don't waste time in a~~

~~- search for a pattern that must be anchored. */~~

~~- if (bufp->used > 0 && (re_opcode_t) bufp->buffer[0] == begbuf && range > 0)~~

~~- {~~

~~- if (startpos > 0)~~

~~- return -1;~~

~~- else~~

~~- range = 1;~~

~~- }~~

~~- /* Update the fastmap now if not correct already. */~~

~~- if (fastmap && !bufp->fastmap_accurate)~~

~~- if (re_compile_fastmap (bufp) == -2)~~

~~- return -2;~~

~~- /* Loop through the string, looking for a place to start matching. */~~

~~- for (;;)~~

~~- {~~

~~- /* If a fastmap is supplied, skip quickly over characters that~~

~~- cannot be the start of a match. If the pattern can match the~~

~~- null string, however, we don't need to skip characters; we want~~

~~- the first null string. */~~

~~- if (fastmap && startpos < total_size && !bufp->can_be_null)~~

~~- {~~

~~- if (range > 0) /* Searching forwards. */~~

~~- {~~

~~- register const char *d;~~

~~- register int lim = 0;~~

~~- int irange = range;~~

~~- if (startpos < size1 && startpos + range >= size1)~~

~~- lim = range - (size1 - startpos);~~

~~- d = (startpos >= size1 ? string2 - size1 : string1) + startpos;~~

~~- /* Written out as an if-else to avoid testing `translate'~~

~~- inside the loop. */~~

~~- if (translate)~~

~~- while (range > lim~~

~~- && !fastmap[(unsigned char)~~

~~- translate[(unsigned char) *d++]])~~

~~- range--;~~

~~- else~~

~~- while (range > lim && !fastmap[(unsigned char) *d++])~~

~~- range--;~~

~~- startpos += irange - range;~~

~~- }~~

~~- else /* Searching backwards. */~~

~~- {~~

~~- register char c = (size1 == 0 || startpos >= size1~~

~~- ? string2[startpos - size1]~~

~~- : string1[startpos]);~~

~~- if (!fastmap[(unsigned char) TRANSLATE (c)])~~

~~- goto advance;~~

~~- }~~

~~- /* If can't match the null string, and that's all we have left, fail. */~~

~~- if (range >= 0 && startpos == total_size && fastmap~~

~~- && !bufp->can_be_null)~~

~~- return -1;~~

~~- val = re_match_2 (bufp, string1, size1, string2, size2,~~

~~- startpos, regs, stop);~~

~~- if (val >= 0)~~

~~- return startpos;~~

~~- if (val == -2)~~

~~- return -2;~~

~~- advance:~~

~~- if (!range)~~

~~- break;~~

~~- else if (range > 0)~~

~~- {~~

~~- range--;~~

~~- startpos++;~~

~~- }~~

~~- else~~

~~- {~~

~~- range++;~~

~~- startpos--;~~

~~- }~~

~~- return -1;~~

~~-} /* re_search_2 */~~

~~-/* Declarations and macros for re_match_2. */~~

~~-static int bcmp_translate ();~~

~~-static boolean alt_match_null_string_p (),~~

~~- common_op_match_null_string_p (),~~

~~- group_match_null_string_p ();~~

~~-/* Structure for per-register (a.k.a. per-group) information.~~

~~- This must not be longer than one word, because we push this value~~

~~- onto the failure stack. Other register information, such as the~~

~~- starting and ending positions (which are addresses), and the list of~~

~~- inner groups (which is a bits list) are maintained in separate~~

~~- variables.~~

~~- We are making a (strictly speaking) nonportable assumption here: that~~

~~- the compiler will pack our bit fields into something that fits into~~

~~- the type of `word', i.e., is something that fits into one item on the~~

~~- failure stack. */~~

~~-typedef union~~

~~- fail_stack_elt_t word;~~

~~- struct~~

~~- {~~

~~- /* This field is one if this group can match the empty string,~~

~~- zero if not. If not yet determined, `MATCH_NULL_UNSET_VALUE'. */~~

~~-#define MATCH_NULL_UNSET_VALUE 3~~

~~- unsigned match_null_string_p : 2;~~

~~- unsigned is_active : 1;~~

~~- unsigned matched_something : 1;~~

~~- unsigned ever_matched_something : 1;~~

~~- } bits;~~

~~-} register_info_type;~~

~~-#define REG_MATCH_NULL_STRING_P(R) ((R).bits.match_null_string_p)~~

~~-#define IS_ACTIVE(R) ((R).bits.is_active)~~

~~-#define MATCHED_SOMETHING(R) ((R).bits.matched_something)~~

~~-#define EVER_MATCHED_SOMETHING(R) ((R).bits.ever_matched_something)~~

~~-/* Call this when have matched a real character; it sets `matched' flags~~

~~- for the subexpressions which we are currently inside. Also records~~

~~- that those subexprs have matched. */~~

~~-#define SET_REGS_MATCHED() \~~

~~- do \~~

~~- { \~~

~~- unsigned r; \~~

~~- for (r = lowest_active_reg; r <= highest_active_reg; r++) \~~

~~- { \~~

~~- MATCHED_SOMETHING (reg_info[r]) \~~

~~- = EVER_MATCHED_SOMETHING (reg_info[r]) \~~

~~- = 1; \~~

~~- } \~~

~~- while (0)~~

~~-/* This converts PTR, a pointer into one of the search strings `string1'~~

~~- and `string2' into an offset from the beginning of that string. */~~

~~-#define POINTER_TO_OFFSET(ptr) \~~

~~- (FIRST_STRING_P (ptr) ? (ptr) - string1 : (ptr) - string2 + size1)~~

~~-/* Registers are set to a sentinel when they haven't yet matched. */~~

~~-#define REG_UNSET_VALUE ((char *) -1)~~

~~-#define REG_UNSET(e) ((e) == REG_UNSET_VALUE)~~

~~-/* Macros for dealing with the split strings in re_match_2. */~~

~~-#define MATCHING_IN_FIRST_STRING (dend == end_match_1)~~

~~-/* Call before fetching a character with *d. This switches over to~~

~~- string2 if necessary. */~~

~~-#define PREFETCH() \~~

~~- while (d == dend) \~~

~~- { \~~

~~- /* End of string2 => fail. */ \~~

~~- if (dend == end_match_2) \~~

~~- goto fail; \~~

~~- /* End of string1 => advance to string2. */ \~~

~~- d = string2; \~~

~~- dend = end_match_2; \~~

~~- }~~

~~-/* Test if at very beginning or at very end of the virtual concatenation~~

~~- of `string1' and `string2'. If only one string, it's `string2'. */~~

~~-#define AT_STRINGS_BEG(d) ((d) == (size1 ? string1 : string2) || !size2)~~

~~-#define AT_STRINGS_END(d) ((d) == end2)~~

~~-/* Test if D points to a character which is word-constituent. We have~~

~~- two special cases to check for: if past the end of string1, look at~~

~~- the first character in string2; and if before the beginning of~~

~~- string2, look at the last character in string1. */~~

~~-#define WORDCHAR_P(d) \~~

~~- (SYNTAX ((d) == end1 ? *string2 \~~

~~- : (d) == string2 - 1 ? *(end1 - 1) : *(d)) \~~

~~- == Sword)~~

~~-/* Test if the character before D and the one at D differ with respect~~

~~- to being word-constituent. */~~

~~-#define AT_WORD_BOUNDARY(d) \~~

~~- (AT_STRINGS_BEG (d) || AT_STRINGS_END (d) \~~

~~- || WORDCHAR_P (d - 1) != WORDCHAR_P (d))~~

~~-/* Free everything we malloc. */~~

~~-#ifdef REGEX_MALLOC~~

~~-#define FREE_VAR(var) if (var) free (var); var = NULL~~

~~-#define FREE_VARIABLES() \~~

~~- do { \~~

~~- FREE_VAR (fail_stack.stack); \~~

~~- FREE_VAR (regstart); \~~

~~- FREE_VAR (regend); \~~

~~- FREE_VAR (old_regstart); \~~

~~- FREE_VAR (old_regend); \~~

~~- FREE_VAR (best_regstart); \~~

~~- FREE_VAR (best_regend); \~~

~~- FREE_VAR (reg_info); \~~

~~- FREE_VAR (reg_dummy); \~~

~~- FREE_VAR (reg_info_dummy); \~~

~~- } while (0)~~

~~-#else /* not REGEX_MALLOC */~~

~~-/* Some MIPS systems (at least) want this to free alloca'd storage. */~~

~~-#define FREE_VARIABLES() alloca (0)~~

~~-#endif /* not REGEX_MALLOC */~~

~~-/* These values must meet several constraints. They must not be valid~~

~~- register values; since we have a limit of 255 registers (because~~

~~- we use only one byte in the pattern for the register number), we can~~

~~- use numbers larger than 255. They must differ by 1, because of~~

~~- NUM_FAILURE_ITEMS above. And the value for the lowest register must~~

~~- be larger than the value for the highest register, so we do not try~~

~~- to actually save any registers when none are active. */~~

~~-#define NO_HIGHEST_ACTIVE_REG (1 << BYTEWIDTH)~~

~~-#define NO_LOWEST_ACTIVE_REG (NO_HIGHEST_ACTIVE_REG + 1)~~

~~-/* Matching routines. */~~

~~-#ifndef emacs /* Emacs never uses this. */~~

~~-/* re_match is like re_match_2 except it takes only a single string. */~~

~~-int~~

~~-re_match (bufp, string, size, pos, regs)~~

~~- struct re_pattern_buffer *bufp;~~

~~- const char *string;~~

~~- int size, pos;~~

~~- struct re_registers *regs;~~

~~- {~~

~~- return re_match_2 (bufp, NULL, 0, string, size, pos, regs, size);~~

~~-#endif /* not emacs */~~

~~-/* re_match_2 matches the compiled pattern in BUFP against the~~

~~- the (virtual) concatenation of STRING1 and STRING2 (of length SIZE1~~

~~- and SIZE2, respectively). We start matching at POS, and stop~~

~~- matching at STOP.~~

~~- If REGS is non-null and the `no_sub' field of BUFP is nonzero, we~~

~~- store offsets for the substring each group matched in REGS. See the~~

~~- documentation for exactly how many groups we fill.~~

~~- We return -1 if no match, -2 if an internal error (such as the~~

~~- failure stack overflowing). Otherwise, we return the length of the~~

~~- matched substring. */~~

~~-int~~

~~-re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)~~

~~- struct re_pattern_buffer *bufp;~~

~~- const char *string1, *string2;~~

~~- int size1, size2;~~

~~- int pos;~~

~~- struct re_registers *regs;~~

~~- int stop;~~

~~- /* General temporaries. */~~

~~- int mcnt;~~

~~- unsigned char *p1;~~

~~- /* Just past the end of the corresponding string. */~~

~~- const char *end1, *end2;~~

~~- /* Pointers into string1 and string2, just past the last characters in~~

~~- each to consider matching. */~~

~~- const char *end_match_1, *end_match_2;~~

~~- /* Where we are in the data, and the end of the current string. */~~

~~- const char *d, *dend;~~

~~- /* Where we are in the pattern, and the end of the pattern. */~~

~~- unsigned char *p = bufp->buffer;~~

~~- register unsigned char *pend = p + bufp->used;~~

~~- /* We use this to map every character in the string. */~~

~~- char *translate = bufp->translate;~~

~~- /* Failure point stack. Each place that can handle a failure further~~

~~- down the line pushes a failure point on this stack. It consists of~~

~~- restart, regend, and reg_info for all registers corresponding to~~

~~- the subexpressions we're currently inside, plus the number of such~~

~~- registers, and, finally, two char *'s. The first char * is where~~

~~- to resume scanning the pattern; the second one is where to resume~~

~~- scanning the strings. If the latter is zero, the failure point is~~

~~- a ``dummy''; if a failure happens and the failure point is a dummy,~~

~~- it gets discarded and the next next one is tried. */~~

~~- fail_stack_type fail_stack;~~

~~-#ifdef DEBUG~~

~~- static unsigned failure_id = 0;~~

~~- unsigned nfailure_points_pushed = 0, nfailure_points_popped = 0;~~

~~-#endif~~

~~- /* We fill all the registers internally, independent of what we~~

~~- return, for use in backreferences. The number here includes~~

~~- an element for register zero. */~~

~~- unsigned num_regs = bufp->re_nsub + 1;~~

~~- /* The currently active registers. */~~

~~- unsigned lowest_active_reg = NO_LOWEST_ACTIVE_REG;~~

~~- unsigned highest_active_reg = NO_HIGHEST_ACTIVE_REG;~~

~~- /* Information on the contents of registers. These are pointers into~~

~~- the input strings; they record just what was matched (on this~~

~~- attempt) by a subexpression part of the pattern, that is, the~~

~~- regnum-th regstart pointer points to where in the pattern we began~~

~~- matching and the regnum-th regend points to right after where we~~

~~- stopped matching the regnum-th subexpression. (The zeroth register~~

~~- keeps track of what the whole pattern matches.) */~~

~~- const char **regstart=NULL, **regend=NULL;~~

~~- /* If a group that's operated upon by a repetition operator fails to~~

~~- match anything, then the register for its start will need to be~~

~~- restored because it will have been set to wherever in the string we~~

~~- are when we last see its open-group operator. Similarly for a~~

~~- register's end. */~~

~~- const char **old_regstart=NULL, **old_regend=NULL;~~

~~- /* The is_active field of reg_info helps us keep track of which (possibly~~

~~- nested) subexpressions we are currently in. The matched_something~~

~~- field of reg_info[reg_num] helps us tell whether or not we have~~

~~- matched any of the pattern so far this time through the reg_num-th~~

~~- subexpression. These two fields get reset each time through any~~

~~- loop their register is in. */~~

~~- register_info_type *reg_info=NULL;~~

~~- /* The following record the register info as found in the above~~

~~- variables when we find a match better than any we've seen before.~~

~~- This happens as we backtrack through the failure points, which in~~

~~- turn happens only if we have not yet matched the entire string. */~~

~~- unsigned best_regs_set = false;~~

~~- const char **best_regstart=NULL, **best_regend=NULL;~~

~~- /* Logically, this is `best_regend[0]'. But we don't want to have to~~

~~- allocate space for that if we're not allocating space for anything~~

~~- else (see below). Also, we never need info about register 0 for~~

~~- any of the other register vectors, and it seems rather a kludge to~~

~~- treat `best_regend' differently than the rest. So we keep track of~~

~~- the end of the best match so far in a separate variable. We~~

~~- initialize this to NULL so that when we backtrack the first time~~

~~- and need to test it, it's not garbage. */~~

~~- const char *match_end = NULL;~~

~~- /* Used when we pop values we don't care about. */~~

~~- const char **reg_dummy=NULL;~~

~~- register_info_type *reg_info_dummy=NULL;~~

~~-#ifdef DEBUG~~

~~- /* Counts the total number of registers pushed. */~~

~~- unsigned num_regs_pushed = 0;~~

~~-#endif~~

~~- DEBUG_PRINT1 ("\n\nEntering re_match_2.\n");~~

~~- INIT_FAIL_STACK ();~~

~~- /* Do not bother to initialize all the register variables if there are~~

~~- no groups in the pattern, as it takes a fair amount of time. If~~

~~- there are groups, we include space for register 0 (the whole~~

~~- pattern), even though we never use it, since it simplifies the~~

~~- array indexing. We should fix this. */~~

~~- if (bufp->re_nsub)~~

~~- {~~

~~- regstart = REGEX_TALLOC (num_regs, const char *);~~

~~- regend = REGEX_TALLOC (num_regs, const char *);~~

~~- old_regstart = REGEX_TALLOC (num_regs, const char *);~~

~~- old_regend = REGEX_TALLOC (num_regs, const char *);~~

~~- best_regstart = REGEX_TALLOC (num_regs, const char *);~~

~~- best_regend = REGEX_TALLOC (num_regs, const char *);~~

~~- reg_info = REGEX_TALLOC (num_regs, register_info_type);~~

~~- reg_dummy = REGEX_TALLOC (num_regs, const char *);~~

~~- reg_info_dummy = REGEX_TALLOC (num_regs, register_info_type);~~

~~- if (!(regstart && regend && old_regstart && old_regend && reg_info~~

~~- && best_regstart && best_regend && reg_dummy && reg_info_dummy))~~

~~- {~~

~~- FREE_VARIABLES ();~~

~~- return -2;~~

~~- }~~

~~-#ifdef REGEX_MALLOC~~

~~- else~~

~~- {~~

~~- /* We must initialize all our variables to NULL, so that~~

~~- `FREE_VARIABLES' doesn't try to free them. */~~

~~- regstart = regend = old_regstart = old_regend = best_regstart~~

~~- = best_regend = reg_dummy = NULL;~~

~~- reg_info = reg_info_dummy = (register_info_type *) NULL;~~

~~- }~~

~~-#endif /* REGEX_MALLOC */~~

~~- /* The starting position is bogus. */~~

~~- if (pos < 0 || pos > size1 + size2)~~

~~- {~~

~~- FREE_VARIABLES ();~~

~~- return -1;~~

~~- }~~

~~- /* Initialize subexpression text positions to -1 to mark ones that no~~

~~- start_memory/stop_memory has been seen for. Also initialize the~~

~~- register information struct. */~~

~~- for (mcnt = 1; mcnt < num_regs; mcnt++)~~

~~- {~~

~~- regstart[mcnt] = regend[mcnt]~~

~~- = old_regstart[mcnt] = old_regend[mcnt] = REG_UNSET_VALUE;~~

~~- REG_MATCH_NULL_STRING_P (reg_info[mcnt]) = MATCH_NULL_UNSET_VALUE;~~

~~- IS_ACTIVE (reg_info[mcnt]) = 0;~~

~~- MATCHED_SOMETHING (reg_info[mcnt]) = 0;~~

~~- EVER_MATCHED_SOMETHING (reg_info[mcnt]) = 0;~~

~~- }~~

~~- /* We move `string1' into `string2' if the latter's empty -- but not if~~

~~- `string1' is null. */~~

~~- if (size2 == 0 && string1 != NULL)~~

~~- {~~

~~- string2 = string1;~~

~~- size2 = size1;~~

~~- string1 = 0;~~

~~- size1 = 0;~~

~~- }~~

~~- end1 = string1 + size1;~~

~~- end2 = string2 + size2;~~

~~- /* Compute where to stop matching, within the two strings. */~~

~~- if (stop <= size1)~~

~~- {~~

~~- end_match_1 = string1 + stop;~~

~~- end_match_2 = string2;~~

~~- }~~

~~- else~~

~~- {~~

~~- end_match_1 = end1;~~

~~- end_match_2 = string2 + stop - size1;~~

~~- }~~

~~- /* `p' scans through the pattern as `d' scans through the data.~~

~~- `dend' is the end of the input string that `d' points within. `d'~~

~~- is advanced into the following input string whenever necessary, but~~

~~- this happens before fetching; therefore, at the beginning of the~~

~~- loop, `d' can be pointing at the end of a string, but it cannot~~

~~- equal `string2'. */~~

~~- if (size1 > 0 && pos <= size1)~~

~~- {~~

~~- d = string1 + pos;~~

~~- dend = end_match_1;~~

~~- }~~

~~- else~~

~~- {~~

~~- d = string2 + pos - size1;~~

~~- dend = end_match_2;~~

~~- }~~

~~- DEBUG_PRINT1 ("The compiled pattern is: ");~~

~~- DEBUG_PRINT_COMPILED_PATTERN (bufp, p, pend);~~

~~- DEBUG_PRINT1 ("The string to match is: `");~~

~~- DEBUG_PRINT_DOUBLE_STRING (d, string1, size1, string2, size2);~~

~~- DEBUG_PRINT1 ("'\n");~~

~~- /* This loops over pattern commands. It exits by returning from the~~

~~- function if the match is complete, or it drops through if the match~~

~~- fails at this starting point in the input data. */~~

~~- for (;;)~~

~~- {~~

~~- DEBUG_PRINT2 ("\n0x%x: ", p);~~

~~- if (p == pend)~~

~~- { /* End of pattern means we might have succeeded. */~~

~~- DEBUG_PRINT1 ("end of pattern ... ");~~

~~- /* If we haven't matched the entire string, and we want the~~

~~- longest match, try backtracking. */~~

~~- if (d != end_match_2)~~

~~- {~~

~~- DEBUG_PRINT1 ("backtracking.\n");~~

~~- if (!FAIL_STACK_EMPTY ())~~

~~- { /* More failure points to try. */~~

~~- boolean same_str_p = (FIRST_STRING_P (match_end)~~

~~- == MATCHING_IN_FIRST_STRING);~~

~~- /* If exceeds best match so far, save it. */~~

~~- if (!best_regs_set~~

~~- || (same_str_p && d > match_end)~~

~~- || (!same_str_p && !MATCHING_IN_FIRST_STRING))~~

~~- {~~

~~- best_regs_set = true;~~

~~- match_end = d;~~

~~- DEBUG_PRINT1 ("\nSAVING match as best so far.\n");~~

~~- for (mcnt = 1; mcnt < num_regs; mcnt++)~~

~~- {~~

~~- best_regstart[mcnt] = regstart[mcnt];~~

~~- best_regend[mcnt] = regend[mcnt];~~

~~- }~~

~~- goto fail;~~

~~- }~~

~~- /* If no failure points, don't restore garbage. */~~

~~- else if (best_regs_set)~~

~~- {~~

~~- restore_best_regs:~~

~~- /* Restore best match. It may happen that `dend ==~~

~~- end_match_1' while the restored d is in string2.~~

~~- For example, the pattern `x.*y.*z' against the~~

~~- strings `x-' and `y-z-', if the two strings are~~

~~- not consecutive in memory. */~~

~~- DEBUG_PRINT1 ("Restoring best registers.\n");~~

~~- d = match_end;~~

~~- dend = ((d >= string1 && d <= end1)~~

~~- ? end_match_1 : end_match_2);~~

~~- for (mcnt = 1; mcnt < num_regs; mcnt++)~~

~~- {~~

~~- regstart[mcnt] = best_regstart[mcnt];~~

~~- regend[mcnt] = best_regend[mcnt];~~

~~- }~~

~~- } /* d != end_match_2 */~~

~~- DEBUG_PRINT1 ("Accepting match.\n");~~

~~- /* If caller wants register contents data back, do it. */~~

~~- if (regs && !bufp->no_sub)~~

~~- {~~

~~- /* Have the register data arrays been allocated? */~~

~~- if (bufp->regs_allocated == REGS_UNALLOCATED)~~

~~- { /* No. So allocate them with malloc. We need one~~

~~- extra element beyond `num_regs' for the `-1' marker~~

~~- GNU code uses. */~~

~~- regs->num_regs = MAX (RE_NREGS, num_regs + 1);~~

~~- regs->start = TALLOC (regs->num_regs, regoff_t);~~

~~- regs->end = TALLOC (regs->num_regs, regoff_t);~~

~~- if (regs->start == NULL || regs->end == NULL)~~

~~- return -2;~~

~~- bufp->regs_allocated = REGS_REALLOCATE;~~

~~- }~~

~~- else if (bufp->regs_allocated == REGS_REALLOCATE)~~

~~- { /* Yes. If we need more elements than were already~~

~~- allocated, reallocate them. If we need fewer, just~~

~~- leave it alone. */~~

~~- if (regs->num_regs < num_regs + 1)~~

~~- {~~

~~- regs->num_regs = num_regs + 1;~~

~~- RETALLOC (regs->start, regs->num_regs, regoff_t);~~

~~- RETALLOC (regs->end, regs->num_regs, regoff_t);~~

~~- if (regs->start == NULL || regs->end == NULL)~~

~~- return -2;~~

~~- }~~

~~- else~~

~~- assert (bufp->regs_allocated == REGS_FIXED);~~

~~- /* Convert the pointer data in `regstart' and `regend' to~~

~~- indices. Register zero has to be set differently,~~

~~- since we haven't kept track of any info for it. */~~

~~- if (regs->num_regs > 0)~~

~~- {~~

~~- regs->start[0] = pos;~~

~~- regs->end[0] = (MATCHING_IN_FIRST_STRING ? d - string1~~

~~- : d - string2 + size1);~~

~~- }~~

~~- /* Go through the first `min (num_regs, regs->num_regs)'~~

~~- registers, since that is all we initialized. */~~

~~- for (mcnt = 1; mcnt < MIN (num_regs, regs->num_regs); mcnt++)~~

~~- {~~

~~- if (REG_UNSET (regstart[mcnt]) || REG_UNSET (regend[mcnt]))~~

~~- regs->start[mcnt] = regs->end[mcnt] = -1;~~

~~- else~~

~~- {~~

~~- regs->start[mcnt] = POINTER_TO_OFFSET (regstart[mcnt]);~~

~~- regs->end[mcnt] = POINTER_TO_OFFSET (regend[mcnt]);~~

~~- }~~

~~- /* If the regs structure we return has more elements than~~

~~- were in the pattern, set the extra elements to -1. If~~

~~- we (re)allocated the registers, this is the case,~~

~~- because we always allocate enough to have at least one~~

~~- -1 at the end. */~~

~~- for (mcnt = num_regs; mcnt < regs->num_regs; mcnt++)~~

~~- regs->start[mcnt] = regs->end[mcnt] = -1;~~

~~- } /* regs && !bufp->no_sub */~~

~~- FREE_VARIABLES ();~~

~~- DEBUG_PRINT4 ("%u failure points pushed, %u popped (%u remain).\n",~~

~~- nfailure_points_pushed, nfailure_points_popped,~~

~~- nfailure_points_pushed - nfailure_points_popped);~~

~~- DEBUG_PRINT2 ("%u registers pushed.\n", num_regs_pushed);~~

~~- mcnt = d - pos - (MATCHING_IN_FIRST_STRING~~

~~- ? string1~~

~~- : string2 - size1);~~

~~- DEBUG_PRINT2 ("Returning %d from re_match_2.\n", mcnt);~~

~~- return mcnt;~~

~~- }~~

~~- /* Otherwise match next pattern command. */~~

~~-#ifdef SWITCH_ENUM_BUG~~

~~- switch ((int) ((re_opcode_t) *p++))~~

~~-#else~~

~~- switch ((re_opcode_t) *p++)~~

~~-#endif~~

~~- {~~

~~- /* Ignore these. Used to ignore the n of succeed_n's which~~

~~- currently have n == 0. */~~

~~- case no_op:~~

~~- DEBUG_PRINT1 ("EXECUTING no_op.\n");~~

~~- break;~~

~~- /* Match the next n pattern characters exactly. The following~~

~~- byte in the pattern defines n, and the n bytes after that~~

~~- are the characters to match. */~~

~~- case exactn:~~

~~- mcnt = *p++;~~

~~- DEBUG_PRINT2 ("EXECUTING exactn %d.\n", mcnt);~~

~~- /* This is written out as an if-else so we don't waste time~~

~~- testing `translate' inside the loop. */~~

~~- if (translate)~~

~~- {~~

~~- do~~

~~- {~~

~~- PREFETCH ();~~

~~- if (translate[(unsigned char) *d++] != (char) *p++)~~

~~- goto fail;~~

~~- }~~

~~- while (--mcnt);~~

~~- }~~

~~- else~~

~~- {~~

~~- do~~

~~- {~~

~~- PREFETCH ();~~

~~- if (*d++ != (char) *p++) goto fail;~~

~~- }~~

~~- while (--mcnt);~~

~~- }~~

~~- SET_REGS_MATCHED ();~~

~~- break;~~

~~- /* Match any character except possibly a newline or a null. */~~

~~- case anychar:~~

~~- DEBUG_PRINT1 ("EXECUTING anychar.\n");~~

~~- PREFETCH ();~~

~~- if ((!(bufp->syntax & RE_DOT_NEWLINE) && TRANSLATE (*d) == '\n')~~

~~- || (bufp->syntax & RE_DOT_NOT_NULL && TRANSLATE (*d) == '\000'))~~

~~- goto fail;~~

~~- SET_REGS_MATCHED ();~~

~~- DEBUG_PRINT2 (" Matched `%d'.\n", *d);~~

~~- d++;~~

~~- break;~~

~~- case charset:~~

~~- case charset_not:~~

~~- {~~

~~- register unsigned char c;~~

~~- boolean not = (re_opcode_t) *(p - 1) == charset_not;~~

~~- DEBUG_PRINT2 ("EXECUTING charset%s.\n", not ? "_not" : "");~~

~~- PREFETCH ();~~

~~- c = TRANSLATE (*d); /* The character to match. */~~

~~- /* Cast to `unsigned' instead of `unsigned char' in case the~~

~~- bit list is a full 32 bytes long. */~~

~~- if (c < (unsigned) (*p * BYTEWIDTH)~~

~~- && p[1 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH)))~~

~~- not = !not;~~

~~- p += 1 + *p;~~

~~- if (!not) goto fail;~~

~~- SET_REGS_MATCHED ();~~

~~- d++;~~

~~- break;~~

~~- }~~

~~- /* The beginning of a group is represented by start_memory.~~

~~- The arguments are the register number in the next byte, and the~~

~~- number of groups inner to this one in the next. The text~~

~~- matched within the group is recorded (in the internal~~

~~- registers data structure) under the register number. */~~

~~- case start_memory:~~

~~- DEBUG_PRINT3 ("EXECUTING start_memory %d (%d):\n", *p, p[1]);~~

~~- /* Find out if this group can match the empty string. */~~

~~- p1 = p; /* To send to group_match_null_string_p. */~~

~~- if (REG_MATCH_NULL_STRING_P (reg_info[*p]) == MATCH_NULL_UNSET_VALUE)~~

~~- REG_MATCH_NULL_STRING_P (reg_info[*p])~~

~~- = group_match_null_string_p (&p1, pend, reg_info);~~

~~- /* Save the position in the string where we were the last time~~

~~- we were at this open-group operator in case the group is~~

~~- operated upon by a repetition operator, e.g., with `(a*)*b'~~

~~- against `ab'; then we want to ignore where we are now in~~

~~- the string in case this attempt to match fails. */~~

~~- old_regstart[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p])~~

~~- ? REG_UNSET (regstart[*p]) ? d : regstart[*p]~~

~~- : regstart[*p];~~

~~- DEBUG_PRINT2 (" old_regstart: %d\n",~~

~~- POINTER_TO_OFFSET (old_regstart[*p]));~~

~~- regstart[*p] = d;~~

~~- DEBUG_PRINT2 (" regstart: %d\n", POINTER_TO_OFFSET (regstart[*p]));~~

~~- IS_ACTIVE (reg_info[*p]) = 1;~~

~~- MATCHED_SOMETHING (reg_info[*p]) = 0;~~

~~- /* This is the new highest active register. */~~

~~- highest_active_reg = *p;~~

~~- /* If nothing was active before, this is the new lowest active~~

~~- register. */~~

~~- if (lowest_active_reg == NO_LOWEST_ACTIVE_REG)~~

~~- lowest_active_reg = *p;~~

~~- /* Move past the register number and inner group count. */~~

~~- p += 2;~~

~~- break;~~

~~- /* The stop_memory opcode represents the end of a group. Its~~

~~- arguments are the same as start_memory's: the register~~

~~- number, and the number of inner groups. */~~

~~- case stop_memory:~~

~~- DEBUG_PRINT3 ("EXECUTING stop_memory %d (%d):\n", *p, p[1]);~~

~~- /* We need to save the string position the last time we were at~~

~~- this close-group operator in case the group is operated~~

~~- upon by a repetition operator, e.g., with `((a*)*(b*)*)*'~~

~~- against `aba'; then we want to ignore where we are now in~~

~~- the string in case this attempt to match fails. */~~

~~- old_regend[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p])~~

~~- ? REG_UNSET (regend[*p]) ? d : regend[*p]~~

~~- : regend[*p];~~

~~- DEBUG_PRINT2 (" old_regend: %d\n",~~

~~- POINTER_TO_OFFSET (old_regend[*p]));~~

~~- regend[*p] = d;~~

~~- DEBUG_PRINT2 (" regend: %d\n", POINTER_TO_OFFSET (regend[*p]));~~

~~- /* This register isn't active anymore. */~~

~~- IS_ACTIVE (reg_info[*p]) = 0;~~

~~- /* If this was the only register active, nothing is active~~

~~- anymore. */~~

~~- if (lowest_active_reg == highest_active_reg)~~

~~- {~~

~~- lowest_active_reg = NO_LOWEST_ACTIVE_REG;~~

~~- highest_active_reg = NO_HIGHEST_ACTIVE_REG;~~

~~- }~~

~~- else~~

~~- { /* We must scan for the new highest active register, since~~

~~- it isn't necessarily one less than now: consider~~

~~- (a(b)c(d(e)f)g). When group 3 ends, after the f), the~~

~~- new highest active register is 1. */~~

~~- unsigned char r = *p - 1;~~

~~- while (r > 0 && !IS_ACTIVE (reg_info[r]))~~

~~- r--;~~

~~- /* If we end up at register zero, that means that we saved~~

~~- the registers as the result of an `on_failure_jump', not~~

~~- a `start_memory', and we jumped to past the innermost~~

~~- `stop_memory'. For example, in ((.)*) we save~~

~~- registers 1 and 2 as a result of the *, but when we pop~~

~~- back to the second ), we are at the stop_memory 1.~~

~~- Thus, nothing is active. */~~

~~- if (r == 0)~~

~~- {~~

~~- lowest_active_reg = NO_LOWEST_ACTIVE_REG;~~

~~- highest_active_reg = NO_HIGHEST_ACTIVE_REG;~~

~~- }~~

~~- else~~

~~- highest_active_reg = r;~~

~~- }~~

~~- /* If just failed to match something this time around with a~~

~~- group that's operated on by a repetition operator, try to~~

~~- force exit from the ``loop'', and restore the register~~

~~- information for this group that we had before trying this~~

~~- last match. */~~

~~- if ((!MATCHED_SOMETHING (reg_info[*p])~~

~~- || (re_opcode_t) p[-3] == start_memory)~~

~~- && (p + 2) < pend)~~

~~- {~~

~~- boolean is_a_jump_n = false;~~

~~- p1 = p + 2;~~

~~- mcnt = 0;~~

~~- switch ((re_opcode_t) *p1++)~~

~~- {~~

~~- case jump_n:~~

~~- is_a_jump_n = true;~~

~~- case pop_failure_jump:~~

~~- case maybe_pop_jump:~~

~~- case jump:~~

~~- case dummy_failure_jump:~~

~~- EXTRACT_NUMBER_AND_INCR (mcnt, p1);~~

~~- if (is_a_jump_n)~~

~~- p1 += 2;~~

~~- break;~~

~~- default:~~

~~- /* do nothing */ ;~~

~~- }~~

~~- p1 += mcnt;~~

~~- /* If the next operation is a jump backwards in the pattern~~

~~- to an on_failure_jump right before the start_memory~~

~~- corresponding to this stop_memory, exit from the loop~~

~~- by forcing a failure after pushing on the stack the~~

~~- on_failure_jump's jump in the pattern, and d. */~~

~~- if (mcnt < 0 && (re_opcode_t) *p1 == on_failure_jump~~

~~- && (re_opcode_t) p1[3] == start_memory && p1[4] == *p)~~

~~- {~~

~~- /* If this group ever matched anything, then restore~~

~~- what its registers were before trying this last~~

~~- failed match, e.g., with `(a*)*b' against `ab' for~~

~~- regstart[1], and, e.g., with `((a*)*(b*)*)*'~~

~~- against `aba' for regend[3].~~

~~- Also restore the registers for inner groups for,~~

~~- e.g., `((a*)(b*))*' against `aba' (register 3 would~~

~~- otherwise get trashed). */~~

~~- if (EVER_MATCHED_SOMETHING (reg_info[*p]))~~

~~- {~~

~~- unsigned r;~~

~~- EVER_MATCHED_SOMETHING (reg_info[*p]) = 0;~~

~~- /* Restore this and inner groups' (if any) registers. */~~

~~- for (r = *p; r < *p + *(p + 1); r++)~~

~~- {~~

~~- regstart[r] = old_regstart[r];~~

~~- /* xx why this test? */~~

~~- if ((int) old_regend[r] >= (int) regstart[r])~~

~~- regend[r] = old_regend[r];~~

~~- }~~

~~- p1++;~~

~~- EXTRACT_NUMBER_AND_INCR (mcnt, p1);~~

~~- PUSH_FAILURE_POINT (p1 + mcnt, d, -2);~~

~~- goto fail;~~

~~- }~~

~~- /* Move past the register number and the inner group count. */~~

~~- p += 2;~~

~~- break;~~

~~- /* \<digit> has been turned into a `duplicate' command which is~~

~~- followed by the numeric value of <digit> as the register number. */~~

~~- case duplicate:~~

~~- {~~

~~- register const char *d2, *dend2;~~

~~- int regno = *p++; /* Get which register to match against. */~~

~~- DEBUG_PRINT2 ("EXECUTING duplicate %d.\n", regno);~~

~~- /* Can't back reference a group which we've never matched. */~~

~~- if (REG_UNSET (regstart[regno]) || REG_UNSET (regend[regno]))~~

~~- goto fail;~~

~~- /* Where in input to try to start matching. */~~

~~- d2 = regstart[regno];~~

~~- /* Where to stop matching; if both the place to start and~~

~~- the place to stop matching are in the same string, then~~

~~- set to the place to stop, otherwise, for now have to use~~

~~- the end of the first string. */~~

~~- dend2 = ((FIRST_STRING_P (regstart[regno])~~

~~- == FIRST_STRING_P (regend[regno]))~~

~~- ? regend[regno] : end_match_1);~~

~~- for (;;)~~

~~- {~~

~~- /* If necessary, advance to next segment in register~~

~~- contents. */~~

~~- while (d2 == dend2)~~

~~- {~~

~~- if (dend2 == end_match_2) break;~~

~~- if (dend2 == regend[regno]) break;~~

~~- /* End of string1 => advance to string2. */~~

~~- d2 = string2;~~

~~- dend2 = regend[regno];~~

~~- }~~

~~- /* At end of register contents => success */~~

~~- if (d2 == dend2) break;~~

~~- /* If necessary, advance to next segment in data. */~~

~~- PREFETCH ();~~

~~- /* How many characters left in this segment to match. */~~

~~- mcnt = dend - d;~~

~~- /* Want how many consecutive characters we can match in~~

~~- one shot, so, if necessary, adjust the count. */~~

~~- if (mcnt > dend2 - d2)~~

~~- mcnt = dend2 - d2;~~

~~- /* Compare that many; failure if mismatch, else move~~

~~- past them. */~~

~~- if (translate~~

~~- ? bcmp_translate (d, d2, mcnt, translate)~~

~~- : bcmp (d, d2, mcnt))~~

~~- goto fail;~~

~~- d += mcnt, d2 += mcnt;~~

~~- }~~

~~- break;~~

~~- /* begline matches the empty string at the beginning of the string~~

~~- (unless `not_bol' is set in `bufp'), and, if~~

~~- `newline_anchor' is set, after newlines. */~~

~~- case begline:~~

~~- DEBUG_PRINT1 ("EXECUTING begline.\n");~~

~~- if (AT_STRINGS_BEG (d))~~

~~- {~~

~~- if (!bufp->not_bol) break;~~

~~- }~~

~~- else if (d[-1] == '\n' && bufp->newline_anchor)~~

~~- {~~

~~- break;~~

~~- }~~

~~- /* In all other cases, we fail. */~~

~~- goto fail;~~

~~- /* endline is the dual of begline. */~~

~~- case endline:~~

~~- DEBUG_PRINT1 ("EXECUTING endline.\n");~~

~~- if (AT_STRINGS_END (d))~~

~~- {~~

~~- if (!bufp->not_eol) break;~~

~~- }~~

~~- /* We have to ``prefetch'' the next character. */~~

~~- else if ((d == end1 ? *string2 : *d) == '\n'~~

~~- && bufp->newline_anchor)~~

~~- {~~

~~- break;~~

~~- }~~

~~- goto fail;~~

~~- /* Match at the very beginning of the data. */~~

~~- case begbuf:~~

~~- DEBUG_PRINT1 ("EXECUTING begbuf.\n");~~

~~- if (AT_STRINGS_BEG (d))~~

~~- break;~~

~~- goto fail;~~

~~- /* Match at the very end of the data. */~~

~~- case endbuf:~~

~~- DEBUG_PRINT1 ("EXECUTING endbuf.\n");~~

~~- if (AT_STRINGS_END (d))~~

~~- break;~~

~~- goto fail;~~

~~- /* on_failure_keep_string_jump is used to optimize `.*\n'. It~~

~~- pushes NULL as the value for the string on the stack. Then~~

~~- `pop_failure_point' will keep the current value for the~~

~~- string, instead of restoring it. To see why, consider~~

~~- matching `foo\nbar' against `.*\n'. The .* matches the foo;~~

~~- then the . fails against the \n. But the next thing we want~~

~~- to do is match the \n against the \n; if we restored the~~

~~- string value, we would be back at the foo.~~

~~- Because this is used only in specific cases, we don't need to~~

~~- check all the things that `on_failure_jump' does, to make~~

~~- sure the right things get saved on the stack. Hence we don't~~

~~- share its code. The only reason to push anything on the~~

~~- stack at all is that otherwise we would have to change~~

~~- `anychar's code to do something besides goto fail in this~~

~~- case; that seems worse than this. */~~

~~- case on_failure_keep_string_jump:~~

~~- DEBUG_PRINT1 ("EXECUTING on_failure_keep_string_jump");~~

~~- EXTRACT_NUMBER_AND_INCR (mcnt, p);~~

~~- DEBUG_PRINT3 (" %d (to 0x%x):\n", mcnt, p + mcnt);~~

~~- PUSH_FAILURE_POINT (p + mcnt, NULL, -2);~~

~~- break;~~

~~- /* Uses of on_failure_jump:~~

~~- Each alternative starts with an on_failure_jump that points~~

~~- to the beginning of the next alternative. Each alternative~~

~~- except the last ends with a jump that in effect jumps past~~

~~- the rest of the alternatives. (They really jump to the~~

~~- ending jump of the following alternative, because tensioning~~

~~- these jumps is a hassle.)~~

~~- Repeats start with an on_failure_jump that points past both~~

~~- the repetition text and either the following jump or~~

~~- pop_failure_jump back to this on_failure_jump. */~~

~~- case on_failure_jump:~~

~~- on_failure:~~

~~- DEBUG_PRINT1 ("EXECUTING on_failure_jump");~~

~~- EXTRACT_NUMBER_AND_INCR (mcnt, p);~~

~~- DEBUG_PRINT3 (" %d (to 0x%x)", mcnt, p + mcnt);~~

~~- /* If this on_failure_jump comes right before a group (i.e.,~~

~~- the original * applied to a group), save the information~~

~~- for that group and all inner ones, so that if we fail back~~

~~- to this point, the group's information will be correct.~~

~~- For example, in $a*$*\1, we need the preceding group,~~

~~- and in $\(a*$b*\)\2, we need the inner group. */~~

~~- /* We can't use `p' to check ahead because we push~~

~~- a failure point to `p + mcnt' after we do this. */~~

~~- p1 = p;~~

~~- /* We need to skip no_op's before we look for the~~

~~- start_memory in case this on_failure_jump is happening as~~

~~- the result of a completed succeed_n, as in $a$\{1,3\}b\1~~

~~- against aba. */~~

~~- while (p1 < pend && (re_opcode_t) *p1 == no_op)~~

~~- p1++;~~

~~- if (p1 < pend && (re_opcode_t) *p1 == start_memory)~~

~~- {~~

~~- /* We have a new highest active register now. This will~~

~~- get reset at the start_memory we are about to get to,~~

~~- but we will have saved all the registers relevant to~~

~~- this repetition op, as described above. */~~

~~- highest_active_reg = *(p1 + 1) + *(p1 + 2);~~

~~- if (lowest_active_reg == NO_LOWEST_ACTIVE_REG)~~

~~- lowest_active_reg = *(p1 + 1);~~

~~- }~~

~~- DEBUG_PRINT1 (":\n");~~

~~- PUSH_FAILURE_POINT (p + mcnt, d, -2);~~

~~- break;~~

~~- /* A smart repeat ends with `maybe_pop_jump'.~~

~~- We change it to either `pop_failure_jump' or `jump'. */~~

~~- case maybe_pop_jump:~~

~~- EXTRACT_NUMBER_AND_INCR (mcnt, p);~~

~~- DEBUG_PRINT2 ("EXECUTING maybe_pop_jump %d.\n", mcnt);~~

~~- {~~

~~- register unsigned char *p2 = p;~~

~~- /* Compare the beginning of the repeat with what in the~~

~~- pattern follows its end. If we can establish that there~~

~~- is nothing that they would both match, i.e., that we~~

~~- would have to backtrack because of (as in, e.g., `a*a')~~

~~- then we can change to pop_failure_jump, because we'll~~

~~- never have to backtrack.~~

~~- This is not true in the case of alternatives: in~~

~~- `(a|ab)*' we do need to backtrack to the `ab' alternative~~

~~- (e.g., if the string was `ab'). But instead of trying to~~

~~- detect that here, the alternative has put on a dummy~~

~~- failure point which is what we will end up popping. */~~

~~- /* Skip over open/close-group commands. */~~

~~- while (p2 + 2 < pend~~

~~- && ((re_opcode_t) *p2 == stop_memory~~

~~- || (re_opcode_t) *p2 == start_memory))~~

~~- p2 += 3; /* Skip over args, too. */~~

~~- /* If we're at the end of the pattern, we can change. */~~

~~- if (p2 == pend)~~

~~- {~~

~~- /* Consider what happens when matching ":$.*$"~~

~~- against ":/". I don't really understand this code~~

~~- yet. */~~

~~- p[-3] = (unsigned char) pop_failure_jump;~~

~~- DEBUG_PRINT1~~

~~- (" End of pattern: change to `pop_failure_jump'.\n");~~

~~- }~~

~~- else if ((re_opcode_t) *p2 == exactn~~

~~- || (bufp->newline_anchor && (re_opcode_t) *p2 == endline))~~

~~- {~~

~~- register unsigned char c~~

~~- = *p2 == (unsigned char) endline ? '\n' : p2[2];~~

~~- p1 = p + mcnt;~~

~~- /* p1[0] ... p1[2] are the `on_failure_jump' corresponding~~

~~- to the `maybe_finalize_jump' of this case. Examine what~~

~~- follows. */~~

~~- if ((re_opcode_t) p1[3] == exactn && p1[5] != c)~~

~~- {~~

~~- p[-3] = (unsigned char) pop_failure_jump;~~

~~- DEBUG_PRINT3 (" %c != %c => pop_failure_jump.\n",~~

~~- c, p1[5]);~~

~~- }~~

~~- else if ((re_opcode_t) p1[3] == charset~~

~~- || (re_opcode_t) p1[3] == charset_not)~~

~~- {~~

~~- int not = (re_opcode_t) p1[3] == charset_not;~~

~~- if (c < (unsigned char) (p1[4] * BYTEWIDTH)~~

~~- && p1[5 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH)))~~

~~- not = !not;~~

~~- /* `not' is equal to 1 if c would match, which means~~

~~- that we can't change to pop_failure_jump. */~~

~~- if (!not)~~

~~- {~~

~~- p[-3] = (unsigned char) pop_failure_jump;~~

~~- DEBUG_PRINT1 (" No match => pop_failure_jump.\n");~~

~~- }~~

~~- p -= 2; /* Point at relative address again. */~~

~~- if ((re_opcode_t) p[-1] != pop_failure_jump)~~

~~- {~~

~~- p[-1] = (unsigned char) jump;~~

~~- DEBUG_PRINT1 (" Match => jump.\n");~~

~~- goto unconditional_jump;~~

~~- }~~

~~- /* Note fall through. */~~

~~- /* The end of a simple repeat has a pop_failure_jump back to~~

~~- its matching on_failure_jump, where the latter will push a~~

~~- failure point. The pop_failure_jump takes off failure~~

~~- points put on by this pop_failure_jump's matching~~

~~- on_failure_jump; we got through the pattern to here from the~~

~~- matching on_failure_jump, so didn't fail. */~~

~~- case pop_failure_jump:~~

~~- {~~

~~- /* We need to pass separate storage for the lowest and~~

~~- highest registers, even though we don't care about the~~

~~- actual values. Otherwise, we will restore only one~~

~~- register from the stack, since lowest will == highest in~~

~~- `pop_failure_point'. */~~

~~- unsigned dummy_low_reg, dummy_high_reg;~~

~~- unsigned char *pdummy;~~

~~- const char *sdummy;~~

~~- DEBUG_PRINT1 ("EXECUTING pop_failure_jump.\n");~~

~~- POP_FAILURE_POINT (sdummy, pdummy,~~

~~- dummy_low_reg, dummy_high_reg,~~

~~- reg_dummy, reg_dummy, reg_info_dummy);~~

~~- }~~

~~- /* Note fall through. */~~

~~- /* Unconditionally jump (without popping any failure points). */~~

~~- case jump:~~

~~- unconditional_jump:~~

~~- EXTRACT_NUMBER_AND_INCR (mcnt, p); /* Get the amount to jump. */~~

~~- DEBUG_PRINT2 ("EXECUTING jump %d ", mcnt);~~

~~- p += mcnt; /* Do the jump. */~~

~~- DEBUG_PRINT2 ("(to 0x%x).\n", p);~~

~~- break;~~

~~- /* We need this opcode so we can detect where alternatives end~~

~~- in `group_match_null_string_p' et al. */~~

~~- case jump_past_alt:~~

~~- DEBUG_PRINT1 ("EXECUTING jump_past_alt.\n");~~

~~- goto unconditional_jump;~~

~~- /* Normally, the on_failure_jump pushes a failure point, which~~

~~- then gets popped at pop_failure_jump. We will end up at~~

~~- pop_failure_jump, also, and with a pattern of, say, `a+', we~~

~~- are skipping over the on_failure_jump, so we have to push~~

~~- something meaningless for pop_failure_jump to pop. */~~

~~- case dummy_failure_jump:~~

~~- DEBUG_PRINT1 ("EXECUTING dummy_failure_jump.\n");~~

~~- /* It doesn't matter what we push for the string here. What~~

~~- the code at `fail' tests is the value for the pattern. */~~

~~- PUSH_FAILURE_POINT (0, 0, -2);~~

~~- goto unconditional_jump;~~

~~- /* At the end of an alternative, we need to push a dummy failure~~

~~- point in case we are followed by a `pop_failure_jump', because~~

~~- we don't want the failure point for the alternative to be~~

~~- popped. For example, matching `(a|ab)*' against `aab'~~

~~- requires that we match the `ab' alternative. */~~

~~- case push_dummy_failure:~~

~~- DEBUG_PRINT1 ("EXECUTING push_dummy_failure.\n");~~

~~- /* See comments just above at `dummy_failure_jump' about the~~

~~- two zeroes. */~~

~~- PUSH_FAILURE_POINT (0, 0, -2);~~

~~- break;~~

~~- /* Have to succeed matching what follows at least n times.~~

~~- After that, handle like `on_failure_jump'. */~~

~~- case succeed_n:~~

~~- EXTRACT_NUMBER (mcnt, p + 2);~~

~~- DEBUG_PRINT2 ("EXECUTING succeed_n %d.\n", mcnt);~~

~~- assert (mcnt >= 0);~~

~~- /* Originally, this is how many times we HAVE to succeed. */~~

~~- if (mcnt > 0)~~

~~- {~~

~~- mcnt--;~~

~~- p += 2;~~

~~- STORE_NUMBER_AND_INCR (p, mcnt);~~

~~- DEBUG_PRINT3 (" Setting 0x%x to %d.\n", p, mcnt);~~

~~- }~~

~~- else if (mcnt == 0)~~

~~- {~~

~~- DEBUG_PRINT2 (" Setting two bytes from 0x%x to no_op.\n", p+2);~~

~~- p[2] = (unsigned char) no_op;~~

~~- p[3] = (unsigned char) no_op;~~

~~- goto on_failure;~~

~~- }~~

~~- break;~~

~~- case jump_n:~~

~~- EXTRACT_NUMBER (mcnt, p + 2);~~

~~- DEBUG_PRINT2 ("EXECUTING jump_n %d.\n", mcnt);~~

~~- /* Originally, this is how many times we CAN jump. */~~

~~- if (mcnt)~~

~~- {~~

~~- mcnt--;~~

~~- STORE_NUMBER (p + 2, mcnt);~~

~~- goto unconditional_jump;~~

~~- }~~

~~- /* If don't have to jump any more, skip over the rest of command. */~~

~~- else~~

~~- p += 4;~~

~~- break;~~

~~- case set_number_at:~~

~~- {~~

~~- DEBUG_PRINT1 ("EXECUTING set_number_at.\n");~~

~~- EXTRACT_NUMBER_AND_INCR (mcnt, p);~~

~~- p1 = p + mcnt;~~

~~- EXTRACT_NUMBER_AND_INCR (mcnt, p);~~

~~- DEBUG_PRINT3 (" Setting 0x%x to %d.\n", p1, mcnt);~~

~~- STORE_NUMBER (p1, mcnt);~~

~~- break;~~

~~- }~~

~~- case wordbound:~~

~~- DEBUG_PRINT1 ("EXECUTING wordbound.\n");~~

~~- if (AT_WORD_BOUNDARY (d))~~

~~- break;~~

~~- goto fail;~~

~~- case notwordbound:~~

~~- DEBUG_PRINT1 ("EXECUTING notwordbound.\n");~~

~~- if (AT_WORD_BOUNDARY (d))~~

~~- goto fail;~~

~~- break;~~

~~- case wordbeg:~~

~~- DEBUG_PRINT1 ("EXECUTING wordbeg.\n");~~

~~- if (WORDCHAR_P (d) && (AT_STRINGS_BEG (d) || !WORDCHAR_P (d - 1)))~~

~~- break;~~

~~- goto fail;~~

~~- case wordend:~~

~~- DEBUG_PRINT1 ("EXECUTING wordend.\n");~~

~~- if (!AT_STRINGS_BEG (d) && WORDCHAR_P (d - 1)~~

~~- && (!WORDCHAR_P (d) || AT_STRINGS_END (d)))~~

~~- break;~~

~~- goto fail;~~

~~-#ifdef emacs~~

~~-#ifdef emacs19~~

~~- case before_dot:~~

~~- DEBUG_PRINT1 ("EXECUTING before_dot.\n");~~

~~- if (PTR_CHAR_POS ((unsigned char *) d) >= point)~~

~~- goto fail;~~

~~- break;~~

~~- case at_dot:~~

~~- DEBUG_PRINT1 ("EXECUTING at_dot.\n");~~

~~- if (PTR_CHAR_POS ((unsigned char *) d) != point)~~

~~- goto fail;~~

~~- break;~~

~~- case after_dot:~~

~~- DEBUG_PRINT1 ("EXECUTING after_dot.\n");~~

~~- if (PTR_CHAR_POS ((unsigned char *) d) <= point)~~

~~- goto fail;~~

~~- break;~~

~~-#else /* not emacs19 */~~

~~- case at_dot:~~

~~- DEBUG_PRINT1 ("EXECUTING at_dot.\n");~~

~~- if (PTR_CHAR_POS ((unsigned char *) d) + 1 != point)~~

~~- goto fail;~~

~~- break;~~

~~-#endif /* not emacs19 */~~

~~- case syntaxspec:~~

~~- DEBUG_PRINT2 ("EXECUTING syntaxspec %d.\n", mcnt);~~

~~- mcnt = *p++;~~

~~- goto matchsyntax;~~

~~- case wordchar:~~

~~- DEBUG_PRINT1 ("EXECUTING Emacs wordchar.\n");~~

~~- mcnt = (int) Sword;~~

~~- matchsyntax:~~

~~- PREFETCH ();~~

~~- if (SYNTAX (*d++) != (enum syntaxcode) mcnt)~~

~~- goto fail;~~

~~- SET_REGS_MATCHED ();~~

~~- break;~~

~~- case notsyntaxspec:~~

~~- DEBUG_PRINT2 ("EXECUTING notsyntaxspec %d.\n", mcnt);~~

~~- mcnt = *p++;~~

~~- goto matchnotsyntax;~~

~~- case notwordchar:~~

~~- DEBUG_PRINT1 ("EXECUTING Emacs notwordchar.\n");~~

~~- mcnt = (int) Sword;~~

~~- matchnotsyntax:~~

~~- PREFETCH ();~~

~~- if (SYNTAX (*d++) == (enum syntaxcode) mcnt)~~

~~- goto fail;~~

~~- SET_REGS_MATCHED ();~~

~~- break;~~

~~-#else /* not emacs */~~

~~- case wordchar:~~

~~- DEBUG_PRINT1 ("EXECUTING non-Emacs wordchar.\n");~~

~~- PREFETCH ();~~

~~- if (!WORDCHAR_P (d))~~

~~- goto fail;~~

~~- SET_REGS_MATCHED ();~~

~~- d++;~~

~~- break;~~

~~- case notwordchar:~~

~~- DEBUG_PRINT1 ("EXECUTING non-Emacs notwordchar.\n");~~

~~- PREFETCH ();~~

~~- if (WORDCHAR_P (d))~~

~~- goto fail;~~

~~- SET_REGS_MATCHED ();~~

~~- d++;~~

~~- break;~~

~~-#endif /* not emacs */~~

~~- default:~~

~~- abort ();~~

~~- }~~

~~- continue; /* Successfully executed one pattern command; keep going. */~~

~~- /* We goto here if a matching operation fails. */~~

~~- fail:~~

~~- if (!FAIL_STACK_EMPTY ())~~

~~- { /* A restart point is known. Restore to that state. */~~

~~- DEBUG_PRINT1 ("\nFAIL:\n");~~

~~- POP_FAILURE_POINT (d, p,~~

~~- lowest_active_reg, highest_active_reg,~~

~~- regstart, regend, reg_info);~~

~~- /* If this failure point is a dummy, try the next one. */~~

~~- if (!p)~~

~~- goto fail;~~

~~- /* If we failed to the end of the pattern, don't examine *p. */~~

~~- assert (p <= pend);~~

~~- if (p < pend)~~

~~- {~~

~~- boolean is_a_jump_n = false;~~

~~- /* If failed to a backwards jump that's part of a repetition~~

~~- loop, need to pop this failure point and use the next one. */~~

~~- switch ((re_opcode_t) *p)~~

~~- {~~

~~- case jump_n:~~

~~- is_a_jump_n = true;~~

~~- case maybe_pop_jump:~~

~~- case pop_failure_jump:~~

~~- case jump:~~

~~- p1 = p + 1;~~

~~- EXTRACT_NUMBER_AND_INCR (mcnt, p1);~~

~~- p1 += mcnt;~~

~~- if ((is_a_jump_n && (re_opcode_t) *p1 == succeed_n)~~

~~- || (!is_a_jump_n~~

~~- && (re_opcode_t) *p1 == on_failure_jump))~~

~~- goto fail;~~

~~- break;~~

~~- default:~~

~~- /* do nothing */ ;~~

~~- }~~

~~- if (d >= string1 && d <= end1)~~

~~- dend = end_match_1;~~

~~- }~~

~~- else~~

~~- break; /* Matching at this starting point really fails. */~~

~~- } /* for (;;) */~~

~~- if (best_regs_set)~~

~~- goto restore_best_regs;~~

~~- FREE_VARIABLES ();~~

~~- return -1; /* Failure to match. */~~

~~-} /* re_match_2 */~~

~~-/* Subroutine definitions for re_match_2. */~~

~~-/* We are passed P pointing to a register number after a start_memory.~~

~~- Return true if the pattern up to the corresponding stop_memory can~~

~~- match the empty string, and false otherwise.~~

~~- If we find the matching stop_memory, sets P to point to one past its number.~~

~~- Otherwise, sets P to an undefined byte less than or equal to END.~~

~~- We don't handle duplicates properly (yet). */~~

~~-static boolean~~

~~-group_match_null_string_p (p, end, reg_info)~~

~~- unsigned char **p, *end;~~

~~- register_info_type *reg_info;~~

~~- int mcnt;~~

~~- /* Point to after the args to the start_memory. */~~

~~- unsigned char *p1 = *p + 2;~~

~~- while (p1 < end)~~

~~- {~~

~~- /* Skip over opcodes that can match nothing, and return true or~~

~~- false, as appropriate, when we get to one that can't, or to the~~

~~- matching stop_memory. */~~

~~- switch ((re_opcode_t) *p1)~~

~~- {~~

~~- /* Could be either a loop or a series of alternatives. */~~

~~- case on_failure_jump:~~

~~- p1++;~~

~~- EXTRACT_NUMBER_AND_INCR (mcnt, p1);~~

~~- /* If the next operation is not a jump backwards in the~~

~~- pattern. */~~

~~- if (mcnt >= 0)~~

~~- {~~

~~- /* Go through the on_failure_jumps of the alternatives,~~

~~- seeing if any of the alternatives cannot match nothing.~~

~~- The last alternative starts with only a jump,~~

~~- whereas the rest start with on_failure_jump and end~~

~~- with a jump, e.g., here is the pattern for `a|b|c':~~

~~- /on_failure_jump/0/6/exactn/1/a/jump_past_alt/0/6~~

~~- /on_failure_jump/0/6/exactn/1/b/jump_past_alt/0/3~~

~~- /exactn/1/c~~

~~- So, we have to first go through the first (n-1)~~

~~- alternatives and then deal with the last one separately. */~~

~~- /* Deal with the first (n-1) alternatives, which start~~

~~- with an on_failure_jump (see above) that jumps to right~~

~~- past a jump_past_alt. */~~

~~- while ((re_opcode_t) p1[mcnt-3] == jump_past_alt)~~

~~- {~~

~~- /* `mcnt' holds how many bytes long the alternative~~

~~- is, including the ending `jump_past_alt' and~~

~~- its number. */~~

~~- if (!alt_match_null_string_p (p1, p1 + mcnt - 3,~~

~~- reg_info))~~

~~- return false;~~

~~- /* Move to right after this alternative, including the~~

~~- jump_past_alt. */~~

~~- p1 += mcnt;~~

~~- /* Break if it's the beginning of an n-th alternative~~

~~- that doesn't begin with an on_failure_jump. */~~

~~- if ((re_opcode_t) *p1 != on_failure_jump)~~

~~- break;~~

~~- /* Still have to check that it's not an n-th~~

~~- alternative that starts with an on_failure_jump. */~~

~~- p1++;~~

~~- EXTRACT_NUMBER_AND_INCR (mcnt, p1);~~

~~- if ((re_opcode_t) p1[mcnt-3] != jump_past_alt)~~

~~- {~~

~~- /* Get to the beginning of the n-th alternative. */~~

~~- p1 -= 3;~~

~~- break;~~

~~- }~~

~~- /* Deal with the last alternative: go back and get number~~

~~- of the `jump_past_alt' just before it. `mcnt' contains~~

~~- the length of the alternative. */~~

~~- EXTRACT_NUMBER (mcnt, p1 - 2);~~

~~- if (!alt_match_null_string_p (p1, p1 + mcnt, reg_info))~~

~~- return false;~~

~~- p1 += mcnt; /* Get past the n-th alternative. */~~

~~- } /* if mcnt > 0 */~~

~~- break;~~

~~- case stop_memory:~~

~~- assert (p1[1] == **p);~~

~~- *p = p1 + 2;~~

~~- return true;~~

~~- default:~~

~~- if (!common_op_match_null_string_p (&p1, end, reg_info))~~

~~- return false;~~

~~- }~~

~~- } /* while p1 < end */~~

~~- return false;~~

~~-} /* group_match_null_string_p */~~

~~-/* Similar to group_match_null_string_p, but doesn't deal with alternatives:~~

~~- It expects P to be the first byte of a single alternative and END one~~

~~- byte past the last. The alternative can contain groups. */~~

~~-static boolean~~

~~-alt_match_null_string_p (p, end, reg_info)~~

~~- unsigned char *p, *end;~~

~~- register_info_type *reg_info;~~

~~- int mcnt;~~

~~- unsigned char *p1 = p;~~

~~- while (p1 < end)~~

~~- {~~

~~- /* Skip over opcodes that can match nothing, and break when we get~~

~~- to one that can't. */~~

~~- switch ((re_opcode_t) *p1)~~

~~- {~~

~~- /* It's a loop. */~~

~~- case on_failure_jump:~~

~~- p1++;~~

~~- EXTRACT_NUMBER_AND_INCR (mcnt, p1);~~

~~- p1 += mcnt;~~

~~- break;~~

~~- default:~~

~~- if (!common_op_match_null_string_p (&p1, end, reg_info))~~

~~- return false;~~

~~- }~~

~~- } /* while p1 < end */~~

~~- return true;~~

~~-} /* alt_match_null_string_p */~~

~~-/* Deals with the ops common to group_match_null_string_p and~~

~~- alt_match_null_string_p.~~

~~- Sets P to one after the op and its arguments, if any. */~~

~~-static boolean~~

~~-common_op_match_null_string_p (p, end, reg_info)~~

~~- unsigned char **p, *end;~~

~~- register_info_type *reg_info;~~

~~- int mcnt;~~

~~- boolean ret;~~

~~- int reg_no;~~

~~- unsigned char *p1 = *p;~~

~~- switch ((re_opcode_t) *p1++)~~

~~- {~~

~~- case no_op:~~

~~- case begline:~~

~~- case endline:~~

~~- case begbuf:~~

~~- case endbuf:~~

~~- case wordbeg:~~

~~- case wordend:~~

~~- case wordbound:~~

~~- case notwordbound:~~

~~-#ifdef emacs~~

~~- case before_dot:~~

~~- case at_dot:~~

~~- case after_dot:~~

~~-#endif~~

~~- break;~~

~~- case start_memory:~~

~~- reg_no = *p1;~~

~~- assert (reg_no > 0 && reg_no <= MAX_REGNUM);~~

~~- ret = group_match_null_string_p (&p1, end, reg_info);~~

~~- /* Have to set this here in case we're checking a group which~~

~~- contains a group and a back reference to it. */~~

~~- if (REG_MATCH_NULL_STRING_P (reg_info[reg_no]) == MATCH_NULL_UNSET_VALUE)~~

~~- REG_MATCH_NULL_STRING_P (reg_info[reg_no]) = ret;~~

~~- if (!ret)~~

~~- return false;~~

~~- break;~~

~~- /* If this is an optimized succeed_n for zero times, make the jump. */~~

~~- case jump:~~

~~- EXTRACT_NUMBER_AND_INCR (mcnt, p1);~~

~~- if (mcnt >= 0)~~

~~- p1 += mcnt;~~

~~- else~~

~~- return false;~~

~~- break;~~

~~- case succeed_n:~~

~~- /* Get to the number of times to succeed. */~~

~~- p1 += 2;~~

~~- EXTRACT_NUMBER_AND_INCR (mcnt, p1);~~

~~- if (mcnt == 0)~~

~~- {~~

~~- p1 -= 4;~~

~~- EXTRACT_NUMBER_AND_INCR (mcnt, p1);~~

~~- p1 += mcnt;~~

~~- }~~

~~- else~~

~~- return false;~~

~~- break;~~

~~- case duplicate:~~

~~- if (!REG_MATCH_NULL_STRING_P (reg_info[*p1]))~~

~~- return false;~~

~~- break;~~

~~- case set_number_at:~~

~~- p1 += 4;~~

~~- default:~~

~~- /* All other opcodes mean we cannot match the empty string. */~~

~~- return false;~~

~~- }~~

~~- *p = p1;~~

~~- return true;~~

~~-} /* common_op_match_null_string_p */~~

~~-/* Return zero if TRANSLATE[S1] and TRANSLATE[S2] are identical for LEN~~

~~- bytes; nonzero otherwise. */~~

~~-static int~~

~~-bcmp_translate (s1, s2, len, translate)~~

~~- unsigned char *s1, *s2;~~

~~- register int len;~~

~~- char *translate;~~

~~- register unsigned char *p1 = s1, *p2 = s2;~~

~~- while (len)~~

~~- {~~

~~- if (translate[*p1++] != translate[*p2++]) return 1;~~

~~- len--;~~

~~- }~~

~~- return 0;~~

~~-/* Entry points for GNU code. */~~

~~-/* re_compile_pattern is the GNU regular expression compiler: it~~

~~- compiles PATTERN (of length SIZE) and puts the result in BUFP.~~

~~- Returns 0 if the pattern was valid, otherwise an error string.~~

~~- Assumes the `allocated' (and perhaps `buffer') and `translate' fields~~

~~- are set in BUFP on entry.~~

~~- We call regex_compile to do the actual compilation. */~~

-const char *

~~-re_compile_pattern (pattern, length, bufp)~~

~~- const char *pattern;~~

~~- int length;~~

~~- struct re_pattern_buffer *bufp;~~

~~- reg_errcode_t ret;~~

~~- /* GNU code is written to assume at least RE_NREGS registers will be set~~

~~- (and at least one extra will be -1). */~~

~~- bufp->regs_allocated = REGS_UNALLOCATED;~~

~~- /* And GNU code determines whether or not to get register information~~

~~- by passing null for the REGS argument to re_match, etc., not by~~

~~- setting no_sub. */~~

~~- bufp->no_sub = 0;~~

~~- /* Match anchors at newline. */~~

~~- bufp->newline_anchor = 1;~~

~~- ret = regex_compile (pattern, length, re_syntax_options, bufp);~~

~~- return re_error_msg[(int) ret];~~

~~-/* Entry points compatible with 4.2 BSD regex library. We don't define~~

~~- them if this is an Emacs or POSIX compilation. */~~

~~-#if !defined (emacs) && !defined (_POSIX_SOURCE)~~

~~-/* BSD has one and only one pattern buffer. */~~

~~-static struct re_pattern_buffer re_comp_buf;~~

-char *

~~-re_comp (s)~~

~~- const char *s;~~

~~- reg_errcode_t ret;~~

~~- if (!s)~~

~~- {~~

~~- if (!re_comp_buf.buffer)~~

~~- return "No previous regular expression";~~

~~- return 0;~~

~~- }~~

~~- if (!re_comp_buf.buffer)~~

~~- {~~

~~- re_comp_buf.buffer = (unsigned char *) malloc (200);~~

~~- if (re_comp_buf.buffer == NULL)~~

~~- return "Memory exhausted";~~

~~- re_comp_buf.allocated = 200;~~

~~- re_comp_buf.fastmap = (char *) malloc (1 << BYTEWIDTH);~~

~~- if (re_comp_buf.fastmap == NULL)~~

~~- return "Memory exhausted";~~

~~- }~~

~~- /* Since `re_exec' always passes NULL for the `regs' argument, we~~

~~- don't need to initialize the pattern buffer fields which affect it. */~~

~~- /* Match anchors at newlines. */~~

~~- re_comp_buf.newline_anchor = 1;~~

~~- ret = regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf);~~

~~- /* Yes, we're discarding `const' here. */~~

~~- return (char *) re_error_msg[(int) ret];~~

~~-int~~

~~-re_exec (s)~~

~~- const char *s;~~

~~- const int len = strlen (s);~~

~~- return~~

~~- 0 <= re_search (&re_comp_buf, s, len, 0, len, (struct re_registers *) 0);~~

~~-#endif /* not emacs and not _POSIX_SOURCE */~~

~~-/* POSIX.2 functions. Don't define these for Emacs. */~~

~~-#ifndef emacs~~

~~-/* regcomp takes a regular expression as a string and compiles it.~~

~~- PREG is a regex_t *. We do not expect any fields to be initialized,~~

~~- since POSIX says we shouldn't. Thus, we set~~

~~- `buffer' to the compiled pattern;~~

~~- `used' to the length of the compiled pattern;~~

~~- `syntax' to RE_SYNTAX_POSIX_EXTENDED if the~~

~~- REG_EXTENDED bit in CFLAGS is set; otherwise, to~~

~~- RE_SYNTAX_POSIX_BASIC;~~

~~- `newline_anchor' to REG_NEWLINE being set in CFLAGS;~~

~~- `fastmap' and `fastmap_accurate' to zero;~~

~~- `re_nsub' to the number of subexpressions in PATTERN.~~

~~- PATTERN is the address of the pattern string.~~

~~- CFLAGS is a series of bits which affect compilation.~~

~~- If REG_EXTENDED is set, we use POSIX extended syntax; otherwise, we~~

~~- use POSIX basic syntax.~~

~~- If REG_NEWLINE is set, then . and [^...] don't match newline.~~

~~- Also, regexec will try a match beginning after every newline.~~

~~- If REG_ICASE is set, then we considers upper- and lowercase~~

~~- versions of letters to be equivalent when matching.~~

~~- If REG_NOSUB is set, then when PREG is passed to regexec, that~~

~~- routine will report only success or failure, and nothing about the~~

~~- registers.~~

~~- It returns 0 if it succeeds, nonzero if it doesn't. (See regex.h for~~

~~- the return codes and their meanings.) */~~

~~-int~~

~~-regcomp (preg, pattern, cflags)~~

~~- regex_t *preg;~~

~~- const char *pattern;~~

~~- int cflags;~~

~~- reg_errcode_t ret;~~

~~- unsigned syntax~~

~~- = (cflags & REG_EXTENDED) ?~~

~~- RE_SYNTAX_POSIX_EXTENDED : RE_SYNTAX_POSIX_BASIC;~~

~~- /* regex_compile will allocate the space for the compiled pattern. */~~

~~- preg->buffer = 0;~~

~~- preg->allocated = 0;~~

~~- /* Don't bother to use a fastmap when searching. This simplifies the~~

~~- REG_NEWLINE case: if we used a fastmap, we'd have to put all the~~

~~- characters after newlines into the fastmap. This way, we just try~~

~~- every character. */~~

~~- preg->fastmap = 0;~~

~~- if (cflags & REG_ICASE)~~

~~- {~~

~~- unsigned i;~~

~~- preg->translate = (char *) malloc (CHAR_SET_SIZE);~~

~~- if (preg->translate == NULL)~~

~~- return (int) REG_ESPACE;~~

~~- /* Map uppercase characters to corresponding lowercase ones. */~~

~~- for (i = 0; i < CHAR_SET_SIZE; i++)~~

~~- preg->translate[i] = ISUPPER (i) ? tolower (i) : i;~~

~~- }~~

~~- else~~

~~- preg->translate = NULL;~~

~~- /* If REG_NEWLINE is set, newlines are treated differently. */~~

~~- if (cflags & REG_NEWLINE)~~

~~- { /* REG_NEWLINE implies neither . nor [^...] match newline. */~~

~~- syntax &= ~RE_DOT_NEWLINE;~~

~~- syntax |= RE_HAT_LISTS_NOT_NEWLINE;~~

~~- /* It also changes the matching behavior. */~~

~~- preg->newline_anchor = 1;~~

~~- }~~

~~- else~~

~~- preg->newline_anchor = 0;~~

~~- preg->no_sub = !!(cflags & REG_NOSUB);~~

~~- /* POSIX says a null character in the pattern terminates it, so we~~

~~- can use strlen here in compiling the pattern. */~~

~~- ret = regex_compile (pattern, strlen (pattern), syntax, preg);~~

~~- /* POSIX doesn't distinguish between an unmatched open-group and an~~

~~- unmatched close-group: both are REG_EPAREN. */~~

~~- if (ret == REG_ERPAREN) ret = REG_EPAREN;~~

~~- return (int) ret;~~

~~-/* regexec searches for a given pattern, specified by PREG, in the~~

~~- string STRING.~~

~~- If NMATCH is zero or REG_NOSUB was set in the cflags argument to~~

~~- `regcomp', we ignore PMATCH. Otherwise, we assume PMATCH has at~~

~~- least NMATCH elements, and we set them to the offsets of the~~

~~- corresponding matched substrings.~~

~~- EFLAGS specifies `execution flags' which affect matching: if~~

~~- REG_NOTBOL is set, then ^ does not match at the beginning of the~~

~~- string; if REG_NOTEOL is set, then $ does not match at the end.~~

~~- We return 0 if we find a match and REG_NOMATCH if not. */~~

~~-int~~

~~-regexec (preg, string, nmatch, pmatch, eflags)~~

~~- const regex_t *preg;~~

~~- const char *string;~~

~~- size_t nmatch;~~

~~- regmatch_t pmatch[];~~

~~- int eflags;~~

~~- int ret;~~

~~- struct re_registers regs;~~

~~- regex_t private_preg;~~

~~- int len = strlen (string);~~

~~- boolean want_reg_info = !preg->no_sub && nmatch > 0;~~

~~- private_preg = *preg;~~

~~- private_preg.not_bol = !!(eflags & REG_NOTBOL);~~

~~- private_preg.not_eol = !!(eflags & REG_NOTEOL);~~

~~- /* The user has told us exactly how many registers to return~~

~~- information about, via `nmatch'. We have to pass that on to the~~

~~- matching routines. */~~

~~- private_preg.regs_allocated = REGS_FIXED;~~

~~- if (want_reg_info)~~

~~- {~~

~~- regs.num_regs = nmatch;~~

~~- regs.start = TALLOC (nmatch, regoff_t);~~

~~- regs.end = TALLOC (nmatch, regoff_t);~~

~~- if (regs.start == NULL || regs.end == NULL)~~

~~- return (int) REG_NOMATCH;~~

~~- }~~

~~- /* Perform the searching operation. */~~

~~- ret = re_search (&private_preg, string, len,~~

~~- /* start: */ 0, /* range: */ len,~~

~~- want_reg_info ? &regs : (struct re_registers *) 0);~~

~~- /* Copy the register information to the POSIX structure. */~~

~~- if (want_reg_info)~~

~~- {~~

~~- if (ret >= 0)~~

~~- {~~

~~- unsigned r;~~

~~- for (r = 0; r < nmatch; r++)~~

~~- {~~

~~- pmatch[r].rm_so = regs.start[r];~~

~~- pmatch[r].rm_eo = regs.end[r];~~

~~- }~~

~~- /* If we needed the temporary register info, free the space now. */~~

~~- free (regs.start);~~

~~- free (regs.end);~~

~~- }~~

~~- /* We want zero return to mean success, unlike `re_search'. */~~

~~- return ret >= 0 ? (int) REG_NOERROR : (int) REG_NOMATCH;~~

~~-/* Returns a message corresponding to an error code, ERRCODE, returned~~

~~- from either regcomp or regexec. We don't use PREG here. */~~

~~-size_t~~

~~-regerror (errcode, preg, errbuf, errbuf_size)~~

~~- int errcode;~~

~~- const regex_t *preg;~~

~~- char *errbuf;~~

~~- size_t errbuf_size;~~

~~- const char *msg;~~

~~- size_t msg_size;~~

~~- if (errcode < 0~~

~~- || errcode >= (sizeof (re_error_msg) / sizeof (re_error_msg[0])))~~

~~- /* Only error codes returned by the rest of the code should be passed~~

~~- to this routine. If we are given anything else, or if other regex~~

~~- code generates an invalid error code, then the program has a bug.~~

~~- Dump core so we can fix it. */~~

~~- abort ();~~

~~- msg = re_error_msg[errcode];~~

~~- /* POSIX doesn't require that we do anything in this case, but why~~

~~- not be nice. */~~

~~- if (! msg)~~

~~- msg = "Success";~~

~~- msg_size = strlen (msg) + 1; /* Includes the null. */~~

~~- if (errbuf_size != 0)~~

~~- {~~

~~- if (msg_size > errbuf_size)~~

~~- {~~

~~- strncpy (errbuf, msg, errbuf_size - 1);~~

~~- errbuf[errbuf_size - 1] = 0;~~

~~- }~~

~~- else~~

~~- strcpy (errbuf, msg);~~

~~- }~~

~~- return msg_size;~~

~~-/* Free dynamically allocated space used by PREG. */~~

~~-void~~

~~-regfree (preg)~~

~~- regex_t *preg;~~

~~- if (preg->buffer != NULL)~~

~~- free (preg->buffer);~~

~~- preg->buffer = NULL;~~

~~- preg->allocated = 0;~~

~~- preg->used = 0;~~

~~- if (preg->fastmap != NULL)~~

~~- free (preg->fastmap);~~

~~- preg->fastmap = NULL;~~

~~- preg->fastmap_accurate = 0;~~

~~- if (preg->translate != NULL)~~

~~- free (preg->translate);~~

~~- preg->translate = NULL;~~

~~-#endif /* not emacs */~~

-/*

~~-Local variables:~~

~~-make-backup-files: t~~

~~-version-control: t~~

~~-trim-versions-without-asking: nil~~

~~-End:~~

~~-*/~~

~~--- a/ignorance/regex.h Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,490 +0,0 @@

~~-/* Definitions for data structures and routines for the regular~~

~~- expression library, version 0.12.~~

~~- This program is free software; you can redistribute it and/or modify~~

~~- it under the terms of the GNU General Public License as published by~~

~~- the Free Software Foundation; either version 2, or (at your option)~~

~~- any later version.~~

~~- This program is distributed in the hope that it will be useful,~~

~~- but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- GNU General Public License for more details.~~

~~- You should have received a copy of the GNU General Public License~~

~~- along with this program; if not, write to the Free Software~~

~~- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */~~

~~-#ifndef __REGEXP_LIBRARY_H__~~

~~-#define __REGEXP_LIBRARY_H__~~

~~-/* POSIX says that <sys/types.h> must be included (by the caller) before~~

~~- <regex.h>. */~~

~~-#ifdef VMS~~

~~-/* VMS doesn't have `size_t' in <sys/types.h>, even though POSIX says it~~

~~- should be there. */~~

~~-#include <stddef.h>~~

~~-#endif~~

~~-/* The following bits are used to determine the regexp syntax we~~

~~- recognize. The set/not-set meanings are chosen so that Emacs syntax~~

~~- remains the value 0. The bits are given in alphabetical order, and~~

~~- the definitions shifted by one from the previous bit; thus, when we~~

~~- add or remove a bit, only one other definition need change. */~~

~~-typedef unsigned reg_syntax_t;~~

~~-/* If this bit is not set, then \ inside a bracket expression is literal.~~

~~- If set, then such a \ quotes the following character. */~~

~~-#define RE_BACKSLASH_ESCAPE_IN_LISTS (1)~~

~~-/* If this bit is not set, then + and ? are operators, and \+ and \? are~~

~~- literals.~~

~~- If set, then \+ and \? are operators and + and ? are literals. */~~

~~-#define RE_BK_PLUS_QM (RE_BACKSLASH_ESCAPE_IN_LISTS << 1)~~

~~-/* If this bit is set, then character classes are supported. They are:~~

~~- [:alpha:], [:upper:], [:lower:], [:digit:], [:alnum:], [:xdigit:],~~

~~- [:space:], [:print:], [:punct:], [:graph:], and [:cntrl:].~~

~~- If not set, then character classes are not supported. */~~

~~-#define RE_CHAR_CLASSES (RE_BK_PLUS_QM << 1)~~

~~-/* If this bit is set, then ^ and $ are always anchors (outside bracket~~

~~- expressions, of course).~~

~~- If this bit is not set, then it depends:~~

~~- ^ is an anchor if it is at the beginning of a regular~~

~~- expression or after an open-group or an alternation operator;~~

~~- $ is an anchor if it is at the end of a regular expression, or~~

~~- before a close-group or an alternation operator.~~

~~- This bit could be (re)combined with RE_CONTEXT_INDEP_OPS, because~~

~~- POSIX draft 11.2 says that * etc. in leading positions is undefined.~~

~~- We already implemented a previous draft which made those constructs~~

~~- invalid, though, so we haven't changed the code back. */~~

~~-#define RE_CONTEXT_INDEP_ANCHORS (RE_CHAR_CLASSES << 1)~~

~~-/* If this bit is set, then special characters are always special~~

~~- regardless of where they are in the pattern.~~

~~- If this bit is not set, then special characters are special only in~~

~~- some contexts; otherwise they are ordinary. Specifically,~~

~~- * + ? and intervals are only special when not after the beginning,~~

~~- open-group, or alternation operator. */~~

~~-#define RE_CONTEXT_INDEP_OPS (RE_CONTEXT_INDEP_ANCHORS << 1)~~

~~-/* If this bit is set, then *, +, ?, and { cannot be first in an re or~~

~~- immediately after an alternation or begin-group operator. */~~

~~-#define RE_CONTEXT_INVALID_OPS (RE_CONTEXT_INDEP_OPS << 1)~~

~~-/* If this bit is set, then . matches newline.~~

~~- If not set, then it doesn't. */~~

~~-#define RE_DOT_NEWLINE (RE_CONTEXT_INVALID_OPS << 1)~~

~~-/* If this bit is set, then . doesn't match NUL.~~

~~- If not set, then it does. */~~

~~-#define RE_DOT_NOT_NULL (RE_DOT_NEWLINE << 1)~~

~~-/* If this bit is set, nonmatching lists [^...] do not match newline.~~

~~- If not set, they do. */~~

~~-#define RE_HAT_LISTS_NOT_NEWLINE (RE_DOT_NOT_NULL << 1)~~

~~-/* If this bit is set, either \{...\} or {...} defines an~~

~~- interval, depending on RE_NO_BK_BRACES.~~

~~- If not set, \{, \}, {, and } are literals. */~~

~~-#define RE_INTERVALS (RE_HAT_LISTS_NOT_NEWLINE << 1)~~

~~-/* If this bit is set, +, ? and | aren't recognized as operators.~~

~~- If not set, they are. */~~

~~-#define RE_LIMITED_OPS (RE_INTERVALS << 1)~~

~~-/* If this bit is set, newline is an alternation operator.~~

~~- If not set, newline is literal. */~~

~~-#define RE_NEWLINE_ALT (RE_LIMITED_OPS << 1)~~

~~-/* If this bit is set, then `{...}' defines an interval, and \{ and \}~~

~~- are literals.~~

~~- If not set, then `\{...\}' defines an interval. */~~

~~-#define RE_NO_BK_BRACES (RE_NEWLINE_ALT << 1)~~

~~-/* If this bit is set, (...) defines a group, and $ and $ are literals.~~

~~- If not set, $...$ defines a group, and ( and ) are literals. */~~

~~-#define RE_NO_BK_PARENS (RE_NO_BK_BRACES << 1)~~

~~-/* If this bit is set, then \<digit> matches <digit>.~~

~~- If not set, then \<digit> is a back-reference. */~~

~~-#define RE_NO_BK_REFS (RE_NO_BK_PARENS << 1)~~

~~-/* If this bit is set, then | is an alternation operator, and \| is literal.~~

~~- If not set, then \| is an alternation operator, and | is literal. */~~

~~-#define RE_NO_BK_VBAR (RE_NO_BK_REFS << 1)~~

~~-/* If this bit is set, then an ending range point collating higher~~

~~- than the starting range point, as in [z-a], is invalid.~~

~~- If not set, then when ending range point collates higher than the~~

~~- starting range point, the range is ignored. */~~

~~-#define RE_NO_EMPTY_RANGES (RE_NO_BK_VBAR << 1)~~

~~-/* If this bit is set, then an unmatched ) is ordinary.~~

~~- If not set, then an unmatched ) is invalid. */~~

~~-#define RE_UNMATCHED_RIGHT_PAREN_ORD (RE_NO_EMPTY_RANGES << 1)~~

~~-/* This global variable defines the particular regexp syntax to use (for~~

~~- some interfaces). When a regexp is compiled, the syntax used is~~

~~- stored in the pattern buffer, so changing this does not affect~~

~~- already-compiled regexps. */~~

~~-extern reg_syntax_t re_syntax_options;~~

~~-/* Define combinations of the above bits for the standard possibilities.~~

~~- (The [[[ comments delimit what gets put into the Texinfo file, so~~

~~- don't delete them!) */~~

~~-/* [[[begin syntaxes]]] */~~

~~-#define RE_SYNTAX_EMACS 0~~

~~-#define RE_SYNTAX_AWK \~~

~~- (RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DOT_NOT_NULL \~~

~~- | RE_NO_BK_PARENS | RE_NO_BK_REFS \~~

~~- | RE_NO_BK_VBAR | RE_NO_EMPTY_RANGES \~~

~~- | RE_UNMATCHED_RIGHT_PAREN_ORD)~~

~~-#define RE_SYNTAX_POSIX_AWK \~~

~~- (RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS)~~

~~-#define RE_SYNTAX_GREP \~~

~~- (RE_BK_PLUS_QM | RE_CHAR_CLASSES \~~

~~- | RE_HAT_LISTS_NOT_NEWLINE | RE_INTERVALS \~~

~~- | RE_NEWLINE_ALT)~~

~~-#define RE_SYNTAX_EGREP \~~

~~- (RE_CHAR_CLASSES | RE_CONTEXT_INDEP_ANCHORS \~~

~~- | RE_CONTEXT_INDEP_OPS | RE_HAT_LISTS_NOT_NEWLINE \~~

~~- | RE_NEWLINE_ALT | RE_NO_BK_PARENS \~~

~~- | RE_NO_BK_VBAR)~~

~~-#define RE_SYNTAX_POSIX_EGREP \~~

~~- (RE_SYNTAX_EGREP | RE_INTERVALS | RE_NO_BK_BRACES)~~

~~-/* P1003.2/D11.2, section 4.20.7.1, lines 5078ff. */~~

~~-#define RE_SYNTAX_ED RE_SYNTAX_POSIX_BASIC~~

~~-#define RE_SYNTAX_SED RE_SYNTAX_POSIX_BASIC~~

~~-/* Syntax bits common to both basic and extended POSIX regex syntax. */~~

~~-#define _RE_SYNTAX_POSIX_COMMON \~~

~~- (RE_CHAR_CLASSES | RE_DOT_NEWLINE | RE_DOT_NOT_NULL \~~

~~- | RE_INTERVALS | RE_NO_EMPTY_RANGES)~~

~~-#define RE_SYNTAX_POSIX_BASIC \~~

~~- (_RE_SYNTAX_POSIX_COMMON | RE_BK_PLUS_QM)~~

~~-/* Differs from ..._POSIX_BASIC only in that RE_BK_PLUS_QM becomes~~

~~- RE_LIMITED_OPS, i.e., \? \+ \| are not recognized. Actually, this~~

~~- isn't minimal, since other operators, such as \`, aren't disabled. */~~

~~-#define RE_SYNTAX_POSIX_MINIMAL_BASIC \~~

~~- (_RE_SYNTAX_POSIX_COMMON | RE_LIMITED_OPS)~~

~~-#define RE_SYNTAX_POSIX_EXTENDED \~~

~~- (_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \~~

~~- | RE_CONTEXT_INDEP_OPS | RE_NO_BK_BRACES \~~

~~- | RE_NO_BK_PARENS | RE_NO_BK_VBAR \~~

~~- | RE_UNMATCHED_RIGHT_PAREN_ORD)~~

~~-/* Differs from ..._POSIX_EXTENDED in that RE_CONTEXT_INVALID_OPS~~

~~- replaces RE_CONTEXT_INDEP_OPS and RE_NO_BK_REFS is added. */~~

~~-#define RE_SYNTAX_POSIX_MINIMAL_EXTENDED \~~

~~- (_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \~~

~~- | RE_CONTEXT_INVALID_OPS | RE_NO_BK_BRACES \~~

~~- | RE_NO_BK_PARENS | RE_NO_BK_REFS \~~

~~- | RE_NO_BK_VBAR | RE_UNMATCHED_RIGHT_PAREN_ORD)~~

~~-/* [[[end syntaxes]]] */~~

~~-/* Maximum number of duplicates an interval can allow. Some systems~~

~~- (erroneously) define this in other header files, but we want our~~

~~- value, so remove any previous define. */~~

~~-#ifdef RE_DUP_MAX~~

~~-#undef RE_DUP_MAX~~

~~-#endif~~

~~-#define RE_DUP_MAX ((1 << 15) - 1)~~

~~-/* POSIX `cflags' bits (i.e., information for `regcomp'). */~~

~~-/* If this bit is set, then use extended regular expression syntax.~~

~~- If not set, then use basic regular expression syntax. */~~

~~-#define REG_EXTENDED 1~~

~~-/* If this bit is set, then ignore case when matching.~~

~~- If not set, then case is significant. */~~

~~-#define REG_ICASE (REG_EXTENDED << 1)~~

~~-/* If this bit is set, then anchors do not match at newline~~

~~- characters in the string.~~

~~- If not set, then anchors do match at newlines. */~~

~~-#define REG_NEWLINE (REG_ICASE << 1)~~

~~-/* If this bit is set, then report only success or fail in regexec.~~

~~- If not set, then returns differ between not matching and errors. */~~

~~-#define REG_NOSUB (REG_NEWLINE << 1)~~

~~-/* POSIX `eflags' bits (i.e., information for regexec). */~~

~~-/* If this bit is set, then the beginning-of-line operator doesn't match~~

~~- the beginning of the string (presumably because it's not the~~

~~- beginning of a line).~~

~~- If not set, then the beginning-of-line operator does match the~~

~~- beginning of the string. */~~

~~-#define REG_NOTBOL 1~~

~~-/* Like REG_NOTBOL, except for the end-of-line. */~~

~~-#define REG_NOTEOL (1 << 1)~~

~~-/* If any error codes are removed, changed, or added, update the~~

~~- `re_error_msg' table in regex.c. */~~

~~-typedef enum~~

~~- REG_NOERROR = 0, /* Success. */~~

~~- REG_NOMATCH, /* Didn't find a match (for regexec). */~~

~~- /* POSIX regcomp return error codes. (In the order listed in the~~

~~- standard.) */~~

~~- REG_BADPAT, /* Invalid pattern. */~~

~~- REG_ECOLLATE, /* Not implemented. */~~

~~- REG_ECTYPE, /* Invalid character class name. */~~

~~- REG_EESCAPE, /* Trailing backslash. */~~

~~- REG_ESUBREG, /* Invalid back reference. */~~

~~- REG_EBRACK, /* Unmatched left bracket. */~~

~~- REG_EPAREN, /* Parenthesis imbalance. */~~

~~- REG_EBRACE, /* Unmatched \{. */~~

~~- REG_BADBR, /* Invalid contents of \{\}. */~~

~~- REG_ERANGE, /* Invalid range end. */~~

~~- REG_ESPACE, /* Ran out of memory. */~~

~~- REG_BADRPT, /* No preceding re for repetition op. */~~

~~- /* Error codes we've added. */~~

~~- REG_EEND, /* Premature end. */~~

~~- REG_ESIZE, /* Compiled pattern bigger than 2^16 bytes. */~~

~~- REG_ERPAREN /* Unmatched ) or \); not returned from regcomp. */~~

~~-} reg_errcode_t;~~

~~-/* This data structure represents a compiled pattern. Before calling~~

~~- the pattern compiler, the fields `buffer', `allocated', `fastmap',~~

~~- `translate', and `no_sub' can be set. After the pattern has been~~

~~- compiled, the `re_nsub' field is available. All other fields are~~

~~- private to the regex routines. */~~

~~-struct re_pattern_buffer~~

~~-/* [[[begin pattern_buffer]]] */~~

~~- /* Space that holds the compiled pattern. It is declared as~~

~~- `unsigned char *' because its elements are~~

~~- sometimes used as array indexes. */~~

~~- unsigned char *buffer;~~

~~- /* Number of bytes to which `buffer' points. */~~

~~- unsigned long allocated;~~

~~- /* Number of bytes actually used in `buffer'. */~~

~~- unsigned long used;~~

~~- /* Syntax setting with which the pattern was compiled. */~~

~~- reg_syntax_t syntax;~~

~~- /* Pointer to a fastmap, if any, otherwise zero. re_search uses~~

~~- the fastmap, if there is one, to skip over impossible~~

~~- starting points for matches. */~~

~~- char *fastmap;~~

~~- /* Either a translate table to apply to all characters before~~

~~- comparing them, or zero for no translation. The translation~~

~~- is applied to a pattern when it is compiled and to a string~~

~~- when it is matched. */~~

~~- char *translate;~~

~~- /* Number of subexpressions found by the compiler. */~~

~~- size_t re_nsub;~~

~~- /* Zero if this pattern cannot match the empty string, one else.~~

~~- Well, in truth it's used only in `re_search_2', to see~~

~~- whether or not we should use the fastmap, so we don't set~~

~~- this absolutely perfectly; see `re_compile_fastmap' (the~~

~~- `duplicate' case). */~~

~~- unsigned can_be_null : 1;~~

~~- /* If REGS_UNALLOCATED, allocate space in the `regs' structure~~

~~- for `max (RE_NREGS, re_nsub + 1)' groups.~~

~~- If REGS_REALLOCATE, reallocate space if necessary.~~

~~- If REGS_FIXED, use what's there. */~~

~~-#define REGS_UNALLOCATED 0~~

~~-#define REGS_REALLOCATE 1~~

~~-#define REGS_FIXED 2~~

~~- unsigned regs_allocated : 2;~~

~~- /* Set to zero when `regex_compile' compiles a pattern; set to one~~

~~- by `re_compile_fastmap' if it updates the fastmap. */~~

~~- unsigned fastmap_accurate : 1;~~

~~- /* If set, `re_match_2' does not return information about~~

~~- subexpressions. */~~

~~- unsigned no_sub : 1;~~

~~- /* If set, a beginning-of-line anchor doesn't match at the~~

~~- beginning of the string. */~~

~~- unsigned not_bol : 1;~~

~~- /* Similarly for an end-of-line anchor. */~~

~~- unsigned not_eol : 1;~~

~~- /* If true, an anchor at a newline matches. */~~

~~- unsigned newline_anchor : 1;~~

~~-/* [[[end pattern_buffer]]] */~~

~~-};~~

~~-typedef struct re_pattern_buffer regex_t;~~

~~-/* search.c (search_buffer) in Emacs needs this one opcode value. It is~~

~~- defined both in `regex.c' and here. */~~

~~-#define RE_EXACTN_VALUE 1~~

~~-/* Type for byte offsets within the string. POSIX mandates this. */~~

~~-typedef int regoff_t;~~

~~-/* This is the structure we store register match data in. See~~

~~- regex.texinfo for a full description of what registers match. */~~

~~-struct re_registers~~

~~- unsigned num_regs;~~

~~- regoff_t *start;~~

~~- regoff_t *end;~~

~~-};~~

~~-/* If `regs_allocated' is REGS_UNALLOCATED in the pattern buffer,~~

~~- `re_match_2' returns information about at least this many registers~~

~~- the first time a `regs' structure is passed. */~~

~~-#ifndef RE_NREGS~~

~~-#define RE_NREGS 30~~

~~-#endif~~

~~-/* POSIX specification for registers. Aside from the different names than~~

~~- `re_registers', POSIX uses an array of structures, instead of a~~

~~- structure of arrays. */~~

~~-typedef struct~~

~~- regoff_t rm_so; /* Byte offset from string's start to substring's start. */~~

~~- regoff_t rm_eo; /* Byte offset from string's start to substring's end. */~~

~~-} regmatch_t;~~

~~-/* Declarations for routines. */~~

~~-/* To avoid duplicating every routine declaration -- once with a~~

~~- prototype (if we are ANSI), and once without (if we aren't) -- we~~

~~- use the following macro to declare argument types. This~~

~~- unfortunately clutters up the declarations a bit, but I think it's~~

~~- worth it. */~~

~~-#if __STDC__~~

~~-#define _RE_ARGS(args) args~~

~~-#else /* not __STDC__ */~~

~~-#define _RE_ARGS(args) ()~~

~~-#endif /* not __STDC__ */~~

~~-/* Sets the current default syntax to SYNTAX, and return the old syntax.~~

~~- You can also simply assign to the `re_syntax_options' variable. */~~

~~-extern reg_syntax_t re_set_syntax _RE_ARGS ((reg_syntax_t syntax));~~

~~-/* Compile the regular expression PATTERN, with length LENGTH~~

~~- and syntax given by the global `re_syntax_options', into the buffer~~

~~- BUFFER. Return NULL if successful, and an error string if not. */~~

~~-extern const char *re_compile_pattern~~

~~- _RE_ARGS ((const char *pattern, int length,~~

~~- struct re_pattern_buffer *buffer));~~

~~-/* Compile a fastmap for the compiled pattern in BUFFER; used to~~

~~- accelerate searches. Return 0 if successful and -2 if was an~~

~~- internal error. */~~

~~-extern int re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer));~~

~~-/* Search in the string STRING (with length LENGTH) for the pattern~~

~~- compiled into BUFFER. Start searching at position START, for RANGE~~

~~- characters. Return the starting position of the match, -1 for no~~

~~- match, or -2 for an internal error. Also return register~~

~~- information in REGS (if REGS and BUFFER->no_sub are nonzero). */~~

~~-extern int re_search~~

~~- _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,~~

~~- int length, int start, int range, struct re_registers *regs));~~

~~-/* Like `re_search', but search in the concatenation of STRING1 and~~

~~- STRING2. Also, stop searching at index START + STOP. */~~

~~-extern int re_search_2~~

~~- _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,~~

~~- int length1, const char *string2, int length2,~~

~~- int start, int range, struct re_registers *regs, int stop));~~

~~-/* Like `re_search', but return how many characters in STRING the regexp~~

~~- in BUFFER matched, starting at position START. */~~

~~-extern int re_match~~

~~- _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,~~

~~- int length, int start, struct re_registers *regs));~~

~~-/* Relates to `re_match' as `re_search_2' relates to `re_search'. */~~

~~-extern int re_match_2~~

~~- _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,~~

~~- int length1, const char *string2, int length2,~~

~~- int start, struct re_registers *regs, int stop));~~

~~-/* Set REGS to hold NUM_REGS registers, storing them in STARTS and~~

~~- ENDS. Subsequent matches using BUFFER and REGS will use this memory~~

~~- for recording register information. STARTS and ENDS must be~~

~~- allocated with malloc, and must each be at least `NUM_REGS * sizeof~~

~~- (regoff_t)' bytes long.~~

~~- If NUM_REGS == 0, then subsequent matches should allocate their own~~

~~- register data.~~

~~- Unless this function is called, the first search or match using~~

~~- PATTERN_BUFFER will allocate its own register data, without~~

~~- freeing the old data. */~~

~~-extern void re_set_registers~~

~~- _RE_ARGS ((struct re_pattern_buffer *buffer, struct re_registers *regs,~~

~~- unsigned num_regs, regoff_t *starts, regoff_t *ends));~~

~~-/* 4.2 bsd compatibility. */~~

~~-extern char *re_comp _RE_ARGS ((const char *));~~

~~-extern int re_exec _RE_ARGS ((const char *));~~

~~-/* POSIX compatibility. */~~

~~-extern int regcomp _RE_ARGS ((regex_t *preg, const char *pattern, int cflags));~~

~~-extern int regexec~~

~~- _RE_ARGS ((const regex_t *preg, const char *string, size_t nmatch,~~

~~- regmatch_t pmatch[], int eflags));~~

~~-extern size_t regerror~~

~~- _RE_ARGS ((int errcode, const regex_t *preg, char *errbuf,~~

~~- size_t errbuf_size));~~

~~-extern void regfree _RE_ARGS ((regex_t *preg));~~

~~-#endif /* not __REGEXP_LIBRARY_H__ */~~

-/*

~~-Local variables:~~

~~-make-backup-files: t~~

~~-version-control: t~~

~~-trim-versions-without-asking: nil~~

~~-End:~~

~~-*/~~

~~--- a/ignorance/support.c Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,158 +0,0 @@

-/*

~~- * This program is free software; you can redistribute it and/or~~

~~- * modify it under the terms of the GNU General Public License~~

~~- * as published by the Free Software Foundation; either version 2~~

~~- * of the License, or (at your option) any later version.~~

- *

~~- * This program is distributed in the hope that it will be useful,~~

~~- * but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- * GNU General Public License for more details.~~

- *

~~- * You should have received a copy of the GNU General Public License~~

~~- * along with this program; if not, write to the Free Software~~

~~- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.~~

~~- */~~

~~-#ifdef HAVE_CONFIG_H~~

~~-# include "../pp_config.h"~~

~~-#endif~~

~~-#include "../common/pp_internal.h"~~

~~-#include <sys/types.h>~~

~~-#include <sys/stat.h>~~

~~-#include <unistd.h>~~

~~-#include <string.h>~~

~~-#include <stdio.h>~~

~~-#include <gtk/gtk.h>~~

~~-#include "ignorance_internal.h"~~

~~-#include "support.h"~~

-GtkWidget*

~~-lookup_widget (GtkWidget *widget,~~

~~- const gchar *widget_name)~~

~~- GtkWidget *parent, *found_widget;~~

~~- for (;;)~~

~~- {~~

~~- if (GTK_IS_MENU (widget))~~

~~- parent = gtk_menu_get_attach_widget (GTK_MENU (widget));~~

~~- else~~

~~- parent = widget->parent;~~

~~- if (!parent)~~

~~- parent = (GtkWidget*) g_object_get_data (G_OBJECT (widget), "GladeParentKey");~~

~~- if (parent == NULL)~~

~~- break;~~

~~- widget = parent;~~

~~- }~~

~~- found_widget = (GtkWidget*) g_object_get_data (G_OBJECT (widget),~~

~~- widget_name);~~

~~- if (!found_widget)~~

~~- g_warning ("Widget not found: %s", widget_name);~~

~~- return found_widget;~~

~~-static GList *pixmaps_directories = NULL;~~

~~-/* Use this function to set the directory containing installed pixmaps. */~~

~~-void~~

~~-add_pixmap_directory (const gchar *directory)~~

~~- pixmaps_directories = g_list_prepend (pixmaps_directories,~~

~~- g_strdup (directory));~~

~~-/* This is an internally used function to find pixmap files. */~~

-static gchar*

~~-find_pixmap_file (const gchar *filename)~~

~~- GList *elem;~~

~~- /* We step through each of the pixmaps directory to find it. */~~

~~- elem = pixmaps_directories;~~

~~- while (elem)~~

~~- {~~

~~- gchar *pathname = g_strdup_printf ("%s%s%s", (gchar*)elem->data,~~

~~- G_DIR_SEPARATOR_S, filename);~~

~~- if (g_file_test (pathname, G_FILE_TEST_EXISTS))~~

~~- return pathname;~~

~~- g_free (pathname);~~

~~- elem = elem->next;~~

~~- }~~

~~- return NULL;~~

~~-/* This is an internally used function to create pixmaps. */~~

-GtkWidget*

~~-create_pixmap (GtkWidget *widget,~~

~~- const gchar *filename)~~

~~- gchar *pathname = NULL;~~

~~- GtkWidget *pixmap;~~

~~- if (!filename || !filename[0])~~

~~- return gtk_image_new ();~~

~~- pathname = find_pixmap_file (filename);~~

~~- if (!pathname)~~

~~- {~~

~~- g_warning (_("Couldn't find pixmap file: %s"), filename);~~

~~- return gtk_image_new ();~~

~~- }~~

~~- pixmap = gtk_image_new_from_file (pathname);~~

~~- g_free (pathname);~~

~~- return pixmap;~~

~~-/* This is an internally used function to create pixmaps. */~~

-GdkPixbuf*

~~-create_pixbuf (const gchar *filename)~~

~~- gchar *pathname = NULL;~~

~~- GdkPixbuf *pixbuf;~~

~~- GError *error = NULL;~~

~~- if (!filename || !filename[0])~~

~~- return NULL;~~

~~- pathname = find_pixmap_file (filename);~~

~~- if (!pathname)~~

~~- {~~

~~- g_warning (_("Couldn't find pixmap file: %s"), filename);~~

~~- return NULL;~~

~~- }~~

~~- pixbuf = gdk_pixbuf_new_from_file (pathname, &error);~~

~~- if (!pixbuf)~~

~~- {~~

~~- fprintf (stderr, "Failed to load pixbuf file: %s: %s\n",~~

~~- pathname, error->message);~~

~~- g_error_free (error);~~

~~- }~~

~~- g_free (pathname);~~

~~- return pixbuf;~~

~~-/* This is used to set ATK action descriptions. */~~

~~-void~~

~~-glade_set_atk_action_description (AtkAction *action,~~

~~- const gchar *action_name,~~

~~- const gchar *description)~~

~~- gint n_actions, i;~~

~~- n_actions = atk_action_get_n_actions (action);~~

~~- for (i = 0; i < n_actions; i++)~~

~~- {~~

~~- if (!strcmp (atk_action_get_name (action, i), action_name))~~

~~- atk_action_set_description (action, i, description);~~

~~- }~~

~~--- a/ignorance/support.h Sun Mar 01 18:49:34 2020 -0600~~

+++ /dev/null Thu Jan 01 00:00:00 1970 +0000

@@ -1,58 +0,0 @@

-/*

~~- * This program is free software; you can redistribute it and/or~~

~~- * modify it under the terms of the GNU General Public License~~

~~- * as published by the Free Software Foundation; either version 2~~

~~- * of the License, or (at your option) any later version.~~

- *

~~- * This program is distributed in the hope that it will be useful,~~

~~- * but WITHOUT ANY WARRANTY; without even the implied warranty of~~

~~- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the~~

~~- * GNU General Public License for more details.~~

- *

~~- * You should have received a copy of the GNU General Public License~~

~~- * along with this program; if not, write to the Free Software~~

~~- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.~~

~~- */~~

~~-#ifndef IGNORANCE_SUPPORT_H~~

~~-#define IGNORANCE_SUPPORT_H~~

~~-#include <gtk/gtk.h>~~

-/*

~~- * Public Functions.~~

~~- */~~

-/*

~~- * This function returns a widget in a component created by Glade.~~

~~- * Call it with the toplevel widget in the component (i.e. a window/dialog),~~

~~- * or alternatively any widget in the component, and the name of the widget~~

~~- * you want returned.~~

~~- */~~

~~-GtkWidget* lookup_widget (GtkWidget *widget,~~

~~- const gchar *widget_name);~~

~~-/* Use this function to set the directory containing installed pixmaps. */~~

~~-void add_pixmap_directory (const gchar *directory);~~

-/*

~~- * Private Functions.~~

~~- */~~

~~-/* This is used to create the pixmaps used in the interface. */~~

~~-GtkWidget* create_pixmap (GtkWidget *widget,~~

~~- const gchar *filename);~~

~~-/* This is used to create the pixbufs used in the interface. */~~

~~-GdkPixbuf* create_pixbuf (const gchar *filename);~~

~~-/* This is used to set ATK action descriptions. */~~

~~-void glade_set_atk_action_description (AtkAction *action,~~

~~- const gchar *action_name,~~

~~- const gchar *description);~~

~~-#endif~~

~~--- a/meson.build Sun Mar 01 18:49:34 2020 -0600~~

+++ b/meson.build Sun Mar 01 18:51:28 2020 -0600

@@ -172,7 +172,6 @@

subdir('hideconv')

subdir('highlight')

subdir('icon-override')

~~-subdir('ignorance')~~

subdir('ignore')

subdir('irc-more')

subdir('irchelper')