Merge branch 'stl'

13 files changed, 145 insertions, 306 deletions

diff --git a/src/Array.h b/src/Array.h
index fc1fca9..20f44c5 100644
--- a/src/Array.h
+++ b/src/Array.h
@@ -1,101 +1,51 @@
 #ifndef __PY_ARRAY_H_
 #define __PY_ARRAY_H_
 
+#include <vector>
+
 namespace PY {
 
 template<typename T>
-class Array {
+class Array : public std::vector<T> {
 public:
-    Array (guint init_size = 0) {
-        m_array = g_array_sized_new (FALSE, FALSE, sizeof (T), init_size);
-    }
-
-    Array (const Array<T> &v) {
-        m_array = g_array_sized_new (FALSE, FALSE, sizeof (T), v.length ());
-        assign (v);
+    Array (guint init_size = 0) : std::vector<T> (){
+        std::vector<T>::reserve (init_size);
     }
 
     ~Array () {
-        g_array_free (m_array, TRUE);
-    }
-
-    T & get (guint i) {
-        return g_array_index (m_array, T, i);
-    }
-
-    const T & get (guint i) const {
-        return g_array_index (m_array, T, i);
     }
 
     guint length (void) const {
-        return m_array->len;
+        return std::vector<T>::size ();
     }
 
     gboolean isEmpty (void) const {
         return length () == 0;
     }
 
-    Array<T> & setSize (guint size) {
-        g_array_set_size (m_array, size);
-        return *this;
-    }
-
     Array<T> & removeAll () {
-        setSize (0);
+        std::vector<T>::resize (0);
         return *this;
     }
 
     Array<T> & append (const T & v) {
-        g_array_append_val (m_array, v);
+        std::vector<T>::push_back (v);
         return *this;
     }
 
     Array<T> & append (const Array<T> & a) {
         for (guint i = 0; i < a.length (); i++)
-            append (a[i]);
-        return *this;
-    }
-
-    Array<T> & insert (guint i, const T & v) {
-        g_array_insert_val (m_array, i, v);
-        return *this;
-    }
-
-    Array<T> & remove (guint i, guint len) {
-        g_array_remove_range (m_array, i, len);
+            append (a.at (i));
         return *this;
     }
 
     Array<T> & push (const T & v) {
-        append (v);
-        return *this;
-    }
-
-    T & pop (void) {
-        T & v = g_array_index (m_array, T, length () - 1);
-        g_array_set_size (m_array, length () - 1);
-        return v;
-    }
-
-    Array<T> & assign (const Array<T> & v) {
-        removeAll ();
-        for (guint i = 0; i < v.length(); i++)
-            append (v[i]);
+        std::vector<T>::push_back (v);
         return *this;
     }
 
-    Array<T> & operator = (const Array<T> & v) {
-        return assign (v);
-    }
-
-    gboolean operator == (const Array<T> &v) const {
-        if (length () != v.length ())
-            return FALSE;
-        for (guint i = 0; i < length (); i++) {
-            if (get (i) != v[i])
-                return FALSE;
-        }
-        return TRUE;
+    void pop (void) {
+        std::vector<T>::pop_back ();
     }
 
     Array<T> & operator << (const T & v) {
@@ -107,19 +57,16 @@ public:
     }
 
     T & operator[] (guint i) {
-        return get (i);
+        return std::vector<T>::operator[](i);
     }
 
     const T & operator[] (guint i) const {
-        return get (i);
+        return std::vector<T>::operator[](i);
     }
 
     operator gboolean (void) const {
         return length () != 0;
     }
-
-protected:
-    GArray *m_array;
 };
 
 };
diff --git a/src/Database.cc b/src/Database.cc
index 0d1668a..39a3b87 100644
--- a/src/Database.cc
+++ b/src/Database.cc
@@ -21,9 +21,7 @@ namespace PY {
 #define DB_PREFETCH_LEN     (6)
 
 Database::Database (void)
-    : m_db (NULL),
-      m_sql (1024),
-      m_buffer (1024)
+    : m_db (NULL)
 {
     init ();
 }
@@ -40,8 +38,8 @@ inline gboolean
 Database::executeSQL (const gchar *sql)
 {
     gchar *errmsg;
-    if (sqlite3_exec (m_db, m_sql, NULL, NULL, &errmsg) != SQLITE_OK) {
-        g_debug ("%s", errmsg);
+    if (sqlite3_exec (m_db, sql, NULL, NULL, &errmsg) != SQLITE_OK) {
+        g_debug ("%s: %s", errmsg, sql);
         sqlite3_free (errmsg);
         return FALSE;
     }
@@ -78,7 +76,7 @@ Database::init (void)
         goto _failed;
     }
 
-    m_sql.truncate (0);
+    m_sql.erase (0);
 
 #if 0
     /* Set synchronous=OFF, write user database will become much faster.
@@ -139,7 +137,7 @@ Database::initUserDatabase (const gchar *userdb)
     m_sql << "INSERT OR IGNORE INTO userdb.desc VALUES " << "('version', '1.2.0');\n"
           << "INSERT OR IGNORE INTO userdb.desc VALUES " << "('uuid', '" << UUID () << "');\n"
           << "INSERT OR IGNORE INTO userdb.desc VALUES " << "('hostname', '" << Hostname () << "');\n"
-          << "INSERT OR IGNORE INTO userdb.desc VALUES " << "('username', '" << getenv ("USERNAME") << "');\n"
+          << "INSERT OR IGNORE INTO userdb.desc VALUES " << "('username', '" << Env ("USERNAME") << "');\n"
           << "INSERT OR IGNORE INTO userdb.desc VALUES " << "('create-time', datetime());\n"
           << "INSERT OR IGNORE INTO userdb.desc VALUES " << "('attach-time', datetime());\n";
 
@@ -184,7 +182,7 @@ _failed:
 void
 Database::prefetch (void)
 {
-    m_sql.truncate (0);
+    m_sql.erase (0);
     for (guint i = 0; i < DB_PREFETCH_LEN; i++)
         m_sql << "SELECT * FROM py_phrase_" << i << ";\n";
     executeSQL (m_sql);
@@ -391,12 +389,12 @@ Database::query (const PinyinArray &pinyin,
     }
 
 
-    m_buffer.truncate (0);
+    m_buffer.erase (0);
     for (guint i = 0; i < m_conditions.length (); i++) {
         if (G_UNLIKELY (i == 0))
-            m_buffer << "  (" << (*m_conditions[i]) << ")\n";
+            m_buffer << "  (" << m_conditions[i].c_str() << ")\n";
         else
-            m_buffer << "  OR (" << (*m_conditions[i]) << ")\n";
+            m_buffer << "  OR (" << m_conditions[i].c_str() << ")\n";
     }
 
     m_sql.printf ("SELECT * FROM ("
@@ -423,8 +421,7 @@ Database::query (const PinyinArray &pinyin,
 
     gint row = 0;
     while (sqlite3_step (stmt) == SQLITE_ROW) {
-        result.setSize (result.length () + 1);
-        Phrase &p = result[result.length() - 1];
+        Phrase p;
 
         g_strlcpy (p.phrase,
                    (gchar *) sqlite3_column_text (stmt, DB_COLUMN_PHRASE),
@@ -437,6 +434,7 @@ Database::query (const PinyinArray &pinyin,
             p.pinyin_id[i][0] = sqlite3_column_int (stmt, (i << 1) + DB_COLUMN_S0);
             p.pinyin_id[i][1] = sqlite3_column_int (stmt, (i << 1) + DB_COLUMN_S0 + 1);
         }
+        result << p;
         row ++;
     }
 
diff --git a/src/Database.h b/src/Database.h
index 7d5bd97..1a5e071 100644
--- a/src/Database.h
+++ b/src/Database.h
@@ -3,49 +3,49 @@
 #define __PY_DATABASE_H__
 
 #include <sqlite3.h>
-#include "Types.h"
-#include "Array.h"
+#include <string>
+#include <vector>
+#include <sstream>
 #include "String.h"
+#include "Types.h"
 #include "PinyinArray.h"
 #include "PhraseArray.h"
 
 namespace PY {
 
-class Conditions : public Array<String *> {
+using namespace std;
+
+class Conditions : public vector<string> {
 public:
-    Conditions (void)
-        : Array<String *> (32),
-          m_length (0) {
+    Conditions (void) :
+        vector<string> (32),
+        m_length (0) {
         reset ();
     }
     ~Conditions (void) {
-        for (guint i = 0; i < Array<String *>::length (); i++) {
-            delete get (i);
-        }
     }
     guint length (void) { return m_length; }
     void reset (void) {
-        m_length = 0;
-        newString ();
+        m_length = 1;
+        operator[](0) = "";
     }
     void _double (void) {
         for (gint i = m_length - 1; i >= 0; i--) {
-            String *str = newString ();
-            *str = *get (i);
+            (*this)[m_length + i] = (*this)[i];
         }
+        m_length = m_length + m_length;
     }
     void triple (void) {
         for (gint i = m_length - 1; i >= 0; i--) {
-            String *str1 = newString ();
-            String *str2 = newString ();
-            *str1 = *str2 = *get (i);
+            operator[](m_length + i) = operator[]((m_length << 1) + i) = operator[](i);
         }
+        m_length = m_length + m_length + m_length;
     }
     void appendVPrintf (gint begin, gint end, const gchar *fmt, va_list args) {
         gchar str[64];
         g_vsnprintf (str, sizeof(str), fmt, args);
         for (gint i = begin; i < end; i++) {
-            (*get (i)) << str;
+            operator[](i) += str;
         }
     }
     void appendPrintf (gint begin, gint end, const gchar *fmt, ...) {
@@ -55,23 +55,10 @@ public:
         va_end (args);
     }
 private:
-    String *newString (void) {
-        String *newstr;
-        if (m_length < Array<String *>::length ()) {
-            newstr = get (m_length++);
-            newstr->truncate (0);
-        }
-        else {
-            newstr = new String (256);
-            append (newstr);
-            m_length ++;
-        }
-        return newstr;
-    }
-private:
     guint m_length;
 };
 
+
 class Database {
 public:
     Database ();
@@ -103,10 +90,10 @@ private:
 
 private:
 private:
-    sqlite3 *m_db;                  /* sqlite3 database */
-    String   m_sql;                 /* sql stmt */
-    String   m_buffer;              /* temp buffer */
-    Conditions m_conditions;        /* select conditions */
+    sqlite3 *m_db;              /* sqlite3 database */
+    String m_sql;               /* sql stmt */
+    String m_buffer;            /* temp buffer */
+    Conditions m_conditions;    /* select conditions */
 };
 
 
diff --git a/src/FullPinyinEditor.cc b/src/FullPinyinEditor.cc
index e7048b5..f1de074 100644
--- a/src/FullPinyinEditor.cc
+++ b/src/FullPinyinEditor.cc
@@ -87,9 +87,10 @@ FullPinyinEditor::removeWordBefore (void)
         cursor = m_pinyin_len;
     }
     else {
-        const Pinyin * p = m_pinyin.pop ();
-        cursor = m_cursor - p->len;
-        m_pinyin_len -= p->len;
+        const Pinyin & p = *m_pinyin.back ();
+        cursor = m_cursor - p.len;
+        m_pinyin_len -= p.len;
+        m_pinyin.pop ();
     }
 
     m_text.erase (cursor, m_cursor - cursor);
@@ -142,9 +143,10 @@ FullPinyinEditor::moveCursorLeftByWord (void)
         return TRUE;
     }
 
-    const Pinyin * p = m_pinyin.pop ();
-    m_cursor -= p->len;
-    m_pinyin_len -= p->len;
+    const Pinyin & p = *m_pinyin.back ();
+    m_cursor -= p.len;
+    m_pinyin_len -= p.len;
+    m_pinyin.pop ();
 
     return TRUE;
 }
diff --git a/src/Makefile.am b/src/Makefile.am
index ca91ac5..dfcc153 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -25,7 +25,7 @@ AM_CFLAGS = \
 	@SQLITE_CFLAGS@ \
 	-DPKGDATADIR=\"$(pkgdatadir)\" \
 	$(NULL)
-AM_LDFLAGS = \
+AM_LDADD = \
 	@IBUS_LIBS@ \
 	@SQLITE_LIBS@ \
 	$(NULL)
@@ -101,7 +101,7 @@ ibus_engine_pinyin_CXXFLAGS = \
 	-DPKGDATADIR=\"$(pkgdatadir)\" \
 	-DLIBEXECDIR=\"$(libexecdir)\" \
 	$(NULL)
-ibus_engine_pinyin_LDFLAGS = \
+ibus_engine_pinyin_LDADD = \
 	@IBUS_LIBS@ \
 	@SQLITE_LIBS@ \
 	@UUID_LIBS@ \
diff --git a/src/PhraseEditor.cc b/src/PhraseEditor.cc
index e6fe668..6248ab5 100644
--- a/src/PhraseEditor.cc
+++ b/src/PhraseEditor.cc
@@ -102,7 +102,7 @@ PhraseEditor::updateCandidates (void)
         return;
 
     if (G_LIKELY (m_candidate_0_phrases.length () > 1)) {
-        m_candidates.setSize (1);
+        m_candidates.resize (1);
         m_candidates[0].reset ();
         for (guint i = 0; i < m_candidate_0_phrases.length (); i++)
             m_candidates[0] += m_candidate_0_phrases[i];
diff --git a/src/PhraseEditor.h b/src/PhraseEditor.h
index afa337e..b7051c0 100644
--- a/src/PhraseEditor.h
+++ b/src/PhraseEditor.h
@@ -1,6 +1,7 @@
 #ifndef __PY_PHRASE_EDITOR_H_
 #define __PY_PHRASE_EDITOR_H_
 
+#include "String.h"
 #include "Database.h"
 #include "PhraseArray.h"
 
diff --git a/src/PinyinArray.h b/src/PinyinArray.h
index 7013948..a3c1bba 100644
--- a/src/PinyinArray.h
+++ b/src/PinyinArray.h
@@ -11,11 +11,8 @@ struct PinyinSegment {
     guint begin;
     guint len;
 
-    void set (const Pinyin *pinyin, guint begin, guint len) {
-        this->pinyin = pinyin;
-        this->begin = begin;
-        this->len = len;
-    }
+    PinyinSegment (const Pinyin *pinyin = NULL, guint begin = 0, guint len = 0)
+        : pinyin (pinyin), begin (begin), len (len) {}
 
     operator const Pinyin * (void) const {
         return pinyin;
@@ -38,11 +35,7 @@ class PinyinArray: public Array<PinyinSegment> {
 public:
     PinyinArray (guint init_size) : Array<PinyinSegment> (init_size) {}
     void append (const Pinyin *pinyin, guint begin, guint len) {
-        g_array_set_size (m_array, length () + 1);
-        PinyinSegment & segment = get (length () - 1);
-        segment.pinyin = pinyin;
-        segment.begin = begin;
-        segment.len = len;
+        push_back (PinyinSegment (pinyin, begin, len));
     }
 };
 
diff --git a/src/PinyinEngine.cc b/src/PinyinEngine.cc
index a9c980b..3a6259b 100644
--- a/src/PinyinEngine.cc
+++ b/src/PinyinEngine.cc
@@ -11,7 +11,6 @@
 #include "Config.h"
 #include "Text.h"
 #include "Util.h"
-#include "WideString.h"
 
 #define _(text) (dgettext (GETTEXT_PACKAGE, text))
 
diff --git a/src/PinyinParser.cc b/src/PinyinParser.cc
index d957820..dd8ef00 100644
--- a/src/PinyinParser.cc
+++ b/src/PinyinParser.cc
@@ -136,10 +136,9 @@ PinyinParser::parse (const String   &pinyin,
 
                         if (((new_py2 != NULL) && (new_py2->len > 1 )) &&
                             (py == NULL || new_py2->len > py->len + 1)) {
-                            result[result.length () - 1].set (
-                                    new_py1,
-                                    result[result.length () - 1].begin,
-                                    new_py1->len);
+                            PinyinSegment & segment = result[result.length () - 1];
+                            segment.pinyin = new_py1;
+                            segment.len = new_py1->len;
                             py = new_py2;
                             p --;
                             break;
@@ -151,10 +150,9 @@ PinyinParser::parse (const String   &pinyin,
 
                     pp = need_resplit (prev_py, py);
                     if (pp != NULL) {
-                        result[result.length () - 1].set (
-                                pp[2],
-                                result[result.length () - 1].begin,
-                                pp[2]->len);
+                        PinyinSegment & segment = result[result.length () - 1];
+                        segment.pinyin = pp[2];
+                        segment.len = pp[2]->len;
                         py = pp[3];
                         p --;
                         break;
@@ -227,34 +225,3 @@ PinyinParser::isPinyin (gint sheng, gint yun, guint option)
 
 };
 
-
-#ifdef TEST
-#include <glib/gprintf.h>
-int main(int argc, char **argv)
-{
-    gint len;
-    GArray *array;
-    Pinyin **p;
-    gchar *str;
-
-    str = "qinaide";
-
-    if (argc > 1)
-        str = argv[1];
-
-    array = g_array_new (TRUE, TRUE, sizeof (Pinyin *));
-
-    len = py_parse_pinyin (str, -1, 0xffffffff, array);
-
-    if (len) {
-        p = (Pinyin **) array->data;
-        while (*p) {
-            g_printf ("%s'", (*p)->text);
-            p ++;
-        }
-    }
-    g_printf ("%s\n", str + len);
-
-    return 0;
-}
-#endif
diff --git a/src/String.h b/src/String.h
index 1b3bb12..6f706f5 100644
--- a/src/String.h
+++ b/src/String.h
@@ -2,190 +2,120 @@
 #define __PY_STRING_H_
 #include <glib.h>
 #include <stdarg.h>
-#include "WideString.h"
+#include <string>
+
 
 namespace PY {
 
-class String {
+class String : public std::string {
 public:
-    String (const gchar *init) {
-        m_string = g_string_new (init);
-    }
-
-    String (const gchar *init, gssize len) {
-        m_string = g_string_new_len (init, len);
-    }
-
-    String (gsize init_size = 0) {
-        m_string = g_string_sized_new (init_size);
-    }
-
-    String (const String &str) {
-        m_string = g_string_sized_new (str.length () + 1);
-        assign (str);
-    }
-
-    String (const WideString &wstr) {
-        m_string = g_string_sized_new (wstr.length() * 6);
-        assign (wstr);
-    }
-
-    ~String (void) {
-        g_string_free (m_string, TRUE);
-    }
-
-    gsize length (void) const {
-        return m_string->len;
-    }
-
-    gsize utf8Length (void) const {
-        return g_utf8_strlen (m_string->str, m_string->len);
-    }
-
-    gboolean isEmpty (void) const {
-        return m_string->len == 0;
-    }
-
-    String & assign (const gchar *str) {
-        g_string_assign (m_string, str);
-        return *this;
-    }
-
-    String & assign (const String &str) {
-        return assign ((const gchar *) str);
-    }
-
-    String & assign (const WideString &wstr) {
-        truncate (0);
-        return append (wstr);
-    }
-
-    String & insert (gint pos, gchar ch) {
-        g_string_insert_c (m_string, pos, ch);
-        return *this;
-    }
-
-    String & append (const gchar *str) {
-        g_string_append (m_string, str);
-        return *this;
-    }
-
-    String & append (const gunichar *wstr) {
-        for (const gunichar *p = wstr; *p != 0; p++)
-            appendUnichar (*p);
-        return *this;
-    }
-
-    String & append (const WideString &wstr) {
-        for (guint i = 0; i < wstr.length (); i++) {
-            appendUnichar (wstr[i]);
-        }
-        return *this;
-    }
-
-    String & appendUnichar (gunichar ch) {
-        g_string_append_unichar (m_string, ch);
-        return *this;
-    }
-
-    String & append (const gchar *str, gint len) {
-        g_string_append_len (m_string, str, len);
-        return *this;
-    }
-
+    String () : std::string () {}
+    String (const gchar *str) : std::string (str) {}
+    String (gint len) : std::string () { reserve (len); }
     String & printf (const gchar *fmt, ...) {
+        gchar *str;
         va_list args;
 
         va_start (args, fmt);
-        g_string_vprintf (m_string, fmt, args);
+        str = g_strdup_vprintf (fmt, args);
         va_end (args);
 
+        assign (str);
+        g_free (str);
         return *this;
     }
 
     String & appendPrintf (const gchar *fmt, ...) {
+        gchar *str;
         va_list args;
 
         va_start (args, fmt);
-        g_string_append_vprintf (m_string, fmt, args);
+        str = g_strdup_vprintf (fmt, args);
         va_end (args);
 
-        return *this;
-    }
+        append (str);
+        g_free (str);
 
-    String & truncate (gint len) {
-        g_string_truncate (m_string, len);
         return *this;
     }
 
-    String & erase (gint pos, gint len) {
-        g_string_erase (m_string, pos, len);
+    String & appendUnichar (gunichar ch) {
+        gchar str[12];
+        gint len;
+        len = g_unichar_to_utf8 (ch, str);
+        str[len] = 0;
+        append (str);
         return *this;
     }
 
-    String & operator = (const gchar *str) {
-        return assign (str);
-    }
-
-    String & operator = (const String &str) {
-        return assign (str);
-    }
-
-    String & operator = (const WideString &wstr) {
-        return assign (wstr);
+    String & insert (gint i, gchar ch) {
+        std::string::insert (i, 1, ch);
+        return *this;
     }
 
-    String & operator += (const gchar *str) {
-        return append (str);
+    String & truncate (guint len) {
+        erase(len);
+        return *this;
     }
 
-    String & operator << (const gchar *str) {
-        return append (str);
+    gboolean isEmpty (void) const {
+        return empty ();
     }
 
-    String & operator << (const gunichar *wstr) {
-        return append (wstr);
+    gsize utf8Length (void) const {
+        return g_utf8_strlen (c_str(), -1);
     }
 
-    String & operator << (const String &str) {
-        return append ((const gchar *) str);
+    String & operator<< (gint i) {
+        return appendPrintf ("%d", i);
     }
 
-    String & operator << (const WideString &wstr) {
-        return append (wstr);
+    String & operator<< (guint i) {
+        return appendPrintf ("%u", i);
     }
 
-    String & operator << (gint d) {
-        g_string_append_printf (m_string, "%d", d);
+    String & operator<< (const gchar ch) {
+        append (1, ch);
         return *this;
     }
 
-    String & operator << (guint d) {
-        g_string_append_printf (m_string, "%u", d);
+    String & operator<< (const gchar *str) {
+        append (str);
         return *this;
     }
 
-    String & operator << (gchar ch) {
-        g_string_append_c (m_string, ch);
+    String & operator<< (const gunichar *wstr) {
+        gchar *str;
+        GError *error;
+        str = g_ucs4_to_utf8 (wstr, -1, NULL, NULL, &error);
+        if (str == NULL) {
+            g_warning ("convert ucs4 to utf8 failed: %s", error->message);
+            g_error_free (error);
+        }
+        else {
+            append (str);
+            g_free (str);
+        }
         return *this;
     }
 
-    gchar operator[] (guint i) {
-        if (i >= length ())
-            return 0;
-        return m_string->str[i];
+    String & operator<< (const String &str) {
+        return operator<< ((const gchar *)str);
     }
 
-    operator const gchar *() const {
-        return m_string->str;
+    String & operator= (const gchar * str) {
+        assign (str);
+        return *this;
     }
 
-    operator gboolean () const {
-        return m_string->len != 0;
+    operator const gchar *(void) const {
+        return this->c_str ();
     }
 
-private:
-    GString *m_string;
+    operator gboolean (void) const {
+        return ! isEmpty ();
+    }
 };
+
 };
 #endif
diff --git a/src/Util.h b/src/Util.h
index aaa0178..836e8f3 100644
--- a/src/Util.h
+++ b/src/Util.h
@@ -3,6 +3,8 @@
 
 #include <uuid/uuid.h>
 #include <sys/utsname.h>
+#include <stdlib.h>
+#include "String.h"
 
 namespace PY {
 
@@ -40,6 +42,18 @@ public:
     }
 };
 
+class Env : public String {
+public:
+    Env (const gchar *name) {
+        gchar *str;
+        str = getenv (name);
+        assign (str != NULL ? str : "");
+    }
+    operator const gchar *(void) const {
+        return c_str();
+    }
+};
+
 class StaticString {
 public:
     StaticString (const gchar *str) : m_string (str) {}
diff --git a/src/WideString.h b/src/WideString.h
index 5a3c313..5518910 100644
--- a/src/WideString.h
+++ b/src/WideString.h
@@ -6,6 +6,7 @@
 
 namespace PY {
 
+#if 0
 class WideString {
 public:
     WideString (const gchar *init) : m_string (g_utf8_strlen (init, -1) + 1) {
@@ -100,6 +101,6 @@ public:
 private:
     Array<gunichar> m_string;
 };
-
+#endif
 };
 #endif