diff --git a/src/ex_docmd.c b/src/ex_docmd.c
index b2cc7f9..ebfac55 100644
--- a/src/ex_docmd.c
+++ b/src/ex_docmd.c
@@ -7043,7 +7043,7 @@
 ex_popup(eap)
     exarg_T	*eap;
 {
-    gui_make_popup(eap->arg);
+    gui_make_popup(eap->arg, eap->forceit);
 }
 #endif
 
diff --git a/src/gui_kde.cc b/src/gui_kde.cc
index fc4664e..4b88e98 100644
--- a/src/gui_kde.cc
+++ b/src/gui_kde.cc
@@ -612,8 +612,9 @@
     menu->widget->popup(QCursor::pos());
 }//}}}
 
+/* TODO: use mouse_pos */
 void
-gui_make_popup (char_u *pathname)//{{{
+gui_make_popup (char_u *pathname, int mouse_pos)//{{{
 {
     vimmenu_T *menu = gui_find_menu(pathname);
 
diff --git a/src/proto/gui_w16.pro b/src/proto/gui_w16.pro
index f1bb434..345f148 100644
--- a/src/proto/gui_w16.pro
+++ b/src/proto/gui_w16.pro
@@ -66,7 +66,7 @@
 void gui_mch_flush __ARGS((void));
 void gui_mch_add_menu __ARGS((vimmenu_T *menu, int pos));
 void gui_mch_show_popupmenu __ARGS((vimmenu_T *menu));
-void gui_make_popup __ARGS((char_u *path_name));
+void gui_make_popup __ARGS((char_u *path_name, int mouse_pos));
 void gui_mch_add_menu_item __ARGS((vimmenu_T *menu, int idx));
 void gui_mch_destroy_menu __ARGS((vimmenu_T *menu));
 void gui_mch_menu_grey __ARGS((vimmenu_T *menu, int grey));
diff --git a/src/proto/gui_w32.pro b/src/proto/gui_w32.pro
index c1fe955..680a9f5 100644
--- a/src/proto/gui_w32.pro
+++ b/src/proto/gui_w32.pro
@@ -72,7 +72,7 @@
 void gui_mch_flush __ARGS((void));
 void gui_mch_add_menu __ARGS((vimmenu_T *menu, int pos));
 void gui_mch_show_popupmenu __ARGS((vimmenu_T *menu));
-void gui_make_popup __ARGS((char_u *path_name));
+void gui_make_popup __ARGS((char_u *path_name, int mouse_pos));
 void gui_make_tearoff __ARGS((char_u *path_name));
 void gui_mch_add_menu_item __ARGS((vimmenu_T *menu, int idx));
 void gui_mch_destroy_menu __ARGS((vimmenu_T *menu));
diff --git a/src/spell.c b/src/spell.c
index 175cf0b..f93027d 100644
--- a/src/spell.c
+++ b/src/spell.c
@@ -6143,7 +6143,7 @@
     if (curbuf->b_cap_prog != NULL)
     {
 	endcol = 0;
-	if (skipwhite(line) - line == curwin->w_cursor.col)
+	if ((int)(skipwhite(line) - line) == (int)curwin->w_cursor.col)
 	{
 	    /* At start of line, check if previous line is empty or sentence
 	     * ends there. */
@@ -9622,10 +9622,10 @@
 	 * int array for easy access. */
 	for (p = badword, badlen = 0; *p != NUL; )
 	    wbadword[badlen++] = mb_ptr2char_adv(&p);
-	++badlen;
+	wbadword[badlen++] = 0;
 	for (p = goodword, goodlen = 0; *p != NUL; )
 	    wgoodword[goodlen++] = mb_ptr2char_adv(&p);
-	++goodlen;
+	wgoodword[goodlen++] = 0;
     }
     else
 #endif
