aboutsummaryrefslogtreecommitdiffstats
path: root/protocols/bee.c
blob: 5800233d1fac0e354ae141202a4459eaeee8bc5b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
  /********************************************************************\
  * BitlBee -- An IRC to other IM-networks gateway                     *
  *                                                                    *
  * Copyright 2002-2010 Wilmer van der Gaast and others                *
  \********************************************************************/

/* Some IM-core stuff                                                   */

/*
  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 with
  the Debian GNU/Linux distribution in /usr/share/common-licenses/GPL;
  if not, write to the Free Software Foundation, Inc., 59 Temple Place,
  Suite 330, Boston, MA  02111-1307  USA
*/

#define BITLBEE_CORE
#include "bitlbee.h"

static char *set_eval_away_status( set_t *set, char *value );

bee_t *bee_new()
{
	bee_t *b = g_new0( bee_t, 1 );
	set_t *s;
	
	s = set_add( &b->set, "auto_connect", "true", set_eval_bool, b );
	s = set_add( &b->set, "auto_reconnect", "true", set_eval_bool, b );
	s = set_add( &b->set, "auto_reconnect_delay", "5*3<900", set_eval_account_reconnect_delay, b );
	s = set_add( &b->set, "away", NULL, set_eval_away_status, b );
	s->flags |= SET_NULL_OK | SET_HIDDEN;
	s = set_add( &b->set, "debug", "false", set_eval_bool, b );
	s = set_add( &b->set, "mobile_is_away", "false", set_eval_bool, b );
	s = set_add( &b->set, "save_on_quit", "true", set_eval_bool, b );
	s = set_add( &b->set, "status", NULL, set_eval_away_status, b );
	s->flags |= SET_NULL_OK;
	s = set_add( &b->set, "strip_html", "true", NULL, b );
	
	b->user = g_malloc( 1 );
	
	return b;
}

void bee_free( bee_t *b )
{
	while( b->accounts )
	{
		if( b->accounts->ic )
			imc_logout( b->accounts->ic, FALSE );
		else if( b->accounts->reconnect )
			cancel_auto_reconnect( b->accounts );
		
		if( b->accounts->ic == NULL )
			account_del( b, b->accounts );
		else
			/* Nasty hack, but account_del() doesn't work in this
			   case and we don't want infinite loops, do we? ;-) */
			b->accounts = b->accounts->next;
	}
	
	while( b->set )
		set_del( &b->set, b->set->key );
	
	bee_group_free( b );
	
	g_free( b->user );
	g_free( b );
}

static char *set_eval_away_status( set_t *set, char *value )
{
	bee_t *bee = set->data;
	account_t *a;
	
	g_free( set->value );
	set->value = g_strdup( value );
	
	for( a = bee->accounts; a; a = a->next )
	{
		struct im_connection *ic = a->ic;
		
		if( ic && ic->flags & OPT_LOGGED_IN )
			imc_away_send_update( ic );
	}
	
	return value;
}
#0000DD; font-weight: bold } /* Literal.Number.Oct */ .highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */ .highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */ .highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */ .highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */ .highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */ .highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */ .highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */ .highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */ .highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */ .highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */ .highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */ .highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */ .highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */ .highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #336699 } /* Name.Variable.Class */ .highlight .vg { color: #dd7700 } /* Name.Variable.Global */ .highlight .vi { color: #3333bb } /* Name.Variable.Instance */ .highlight .vm { color: #336699 } /* Name.Variable.Magic */ .highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
require 'rdoc/markup/inline'

##
# Manages changes of attributes in a block of text

class RDoc::Markup::AttributeManager

  ##
  # The NUL character

  NULL = "\000".freeze

  ##
  # We work by substituting non-printing characters in to the text. For now
  # I'm assuming that I can substitute a character in the range 0..8 for a 7
  # bit character without damaging the encoded string, but this might be
  # optimistic

  A_PROTECT  = 004
  PROTECT_ATTR  = A_PROTECT.chr

  ##
  # This maps delimiters that occur around words (such as *bold* or +tt+)
  # where the start and end delimiters and the same. This lets us optimize
  # the regexp

  MATCHING_WORD_PAIRS = {}

  ##
  # And this is used when the delimiters aren't the same. In this case the
  # hash maps a pattern to the attribute character

  WORD_PAIR_MAP = {}

  ##
  # This maps HTML tags to the corresponding attribute char

  HTML_TAGS = {}

  ##
  # And this maps _special_ sequences to a name. A special sequence is
  # something like a WikiWord

  SPECIAL = {}

  ##
  # Return an attribute object with the given turn_on and turn_off bits set

  def attribute(turn_on, turn_off)
    RDoc::Markup::AttrChanger.new turn_on, turn_off
  end

  def change_attribute(current, new)
    diff = current ^ new
    attribute(new & diff, current & diff)
  end

  def changed_attribute_by_name(current_set, new_set)
    current = new = 0
    current_set.each do |name|
      current |= RDoc::Markup::Attribute.bitmap_for(name)
    end

    new_set.each do |name|
      new |= RDoc::Markup::Attribute.bitmap_for(name)
    end

    change_attribute(current, new)
  end

  def copy_string(start_pos, end_pos)
    res = @str[start_pos...end_pos]
    res.gsub!(/\000/, '')
    res
  end

  ##
  # Map attributes like <b>text</b>to the sequence
  # \001\002<char>\001\003<char>, where <char> is a per-attribute specific
  # character

  def convert_attrs(str, attrs)
    # first do matching ones
    tags = MATCHING_WORD_PAIRS.keys.join("")

    re = /(^|\W)([#{tags}])([#:\\]?[\w.\/-]+?\S?)\2(\W|$)/

    1 while str.gsub!(re) do
      attr = MATCHING_WORD_PAIRS[$2]
      attrs.set_attrs($`.length + $1.length + $2.length, $3.length, attr)
      $1 + NULL * $2.length + $3 + NULL * $2.length + $4
    end

    # then non-matching
    unless WORD_PAIR_MAP.empty? then
      WORD_PAIR_MAP.each do |regexp, attr|
        str.gsub!(regexp) {
          attrs.set_attrs($`.length + $1.length, $2.length, attr)
          NULL * $1.length + $2 + NULL * $3.length
        }
      end
    end
  end

  ##
  # Converts HTML tags to RDoc attributes

  def convert_html(str, attrs)
    tags = HTML_TAGS.keys.join '|'

    1 while str.gsub!(/<(#{tags})>(.*?)<\/\1>/i) {
      attr = HTML_TAGS[$1.downcase]
      html_length = $1.length + 2
      seq = NULL * html_length
      attrs.set_attrs($`.length + html_length, $2.length, attr)
      seq + $2 + seq + NULL
    }
  end

  ##
  # Converts special sequences to RDoc attributes

  def convert_specials(str, attrs)
    unless SPECIAL.empty?
      SPECIAL.each do |regexp, attr|
        str.scan(regexp) do
          attrs.set_attrs($`.length, $&.length,
                          attr | RDoc::Markup::Attribute::SPECIAL)
        end
      end
    end
  end

  ##
  # A \ in front of a character that would normally be processed turns off
  # processing. We do this by turning \< into <#{PROTECT}

  PROTECTABLE = %w[<\\]

  ##
  # Escapes special sequences of text to prevent conversion to RDoc

  def mask_protected_sequences
    protect_pattern = Regexp.new("\\\\([#{Regexp.escape(PROTECTABLE.join(''))}])")
    @str.gsub!(protect_pattern, "\\1#{PROTECT_ATTR}")
  end

  ##
  # Unescapes special sequences of text

  def unmask_protected_sequences
    @str.gsub!(/(.)#{PROTECT_ATTR}/, "\\1\000")
  end

  ##
  # Creates a new attribute manager that understands bold, emphasized and
  # teletype text.

  def initialize
    add_word_pair("*", "*", :BOLD)
    add_word_pair("_", "_", :EM)
    add_word_pair("+", "+", :TT)

    add_html("em", :EM)
    add_html("i",  :EM)
    add_html("b",  :BOLD)
    add_html("tt",   :TT)
    add_html("code", :TT)
  end

  ##
  # Adds a markup class with +name+ for words wrapped in the +start+ and
  # +stop+ character.  To make words wrapped with "*" bold:
  #
  #   am.add_word_pair '*', '*', :BOLD

  def add_word_pair(start, stop, name)
    raise ArgumentError, "Word flags may not start with '<'" if
      start[0,1] == '<'

    bitmap = RDoc::Markup::Attribute.bitmap_for name

    if start == stop then
      MATCHING_WORD_PAIRS[start] = bitmap
    else
      pattern = /(#{Regexp.escape start})(\S+)(#{Regexp.escape stop})/
      WORD_PAIR_MAP[pattern] = bitmap
    end

    PROTECTABLE << start[0,1]
    PROTECTABLE.uniq!
  end

  ##
  # Adds a markup class with +name+ for words surrounded by HTML tag +tag+.
  # To process emphasis tags:
  #
  #   am.add_html 'em', :EM

  def add_html(tag, name)
    HTML_TAGS[tag.downcase] = RDoc::Markup::Attribute.bitmap_for name
  end

  ##
  # Adds a special handler for +pattern+ with +name+.  A simple URL handler
  # would be:
  #
  #   @am.add_special(/((https?:)\S+\w)/, :HYPERLINK)

  def add_special(pattern, name)
    SPECIAL[pattern] = RDoc::Markup::Attribute.bitmap_for name
  end

  ##
  # Processes +str+ converting attributes, HTML and specials

  def flow(str)
    @str = str

    mask_protected_sequences

    @attrs = RDoc::Markup::AttrSpan.new @str.length

    convert_attrs(@str, @attrs)
    convert_html(@str, @attrs)
    convert_specials(str, @attrs)

    unmask_protected_sequences

    split_into_flow
  end

  ##
  # Debug method that prints a string along with its attributes

  def display_attributes
    puts
    puts @str.tr(NULL, "!")
    bit = 1
    16.times do |bno|
      line = ""
      @str.length.times do |i|
        if (@attrs[i] & bit) == 0
          line << " "
        else
          if bno.zero?
            line << "S"
          else
            line << ("%d" % (bno+1))
          end
        end
      end
      puts(line) unless line =~ /^ *$/
      bit <<= 1
    end
  end

  def split_into_flow
    res = []
    current_attr = 0
    str = ""

    str_len = @str.length

    # skip leading invisible text
    i = 0
    i += 1 while i < str_len and @str[i].chr == "\0"
    start_pos = i

    # then scan the string, chunking it on attribute changes
    while i < str_len
      new_attr = @attrs[i]
      if new_attr != current_attr
        if i > start_pos
          res << copy_string(start_pos, i)
          start_pos = i
        end

        res << change_attribute(current_attr, new_attr)
        current_attr = new_attr

        if (current_attr & RDoc::Markup::Attribute::SPECIAL) != 0 then
          i += 1 while
            i < str_len and (@attrs[i] & RDoc::Markup::Attribute::SPECIAL) != 0

          res << RDoc::Markup::Special.new(current_attr,
                                           copy_string(start_pos, i))
          start_pos = i
          next
        end
      end

      # move on, skipping any invisible characters
      begin
        i += 1
      end while i < str_len and @str[i].chr == "\0"
    end

    # tidy up trailing text
    if start_pos < str_len
      res << copy_string(start_pos, str_len)
    end

    # and reset to all attributes off
    res << change_attribute(current_attr, 0) if current_attr != 0

    res
  end

end