TEXT_PROPERTY_APPEND
};
-/* If o1 is a cons whose cdr is a cons, return non-zero and set o2 to
- the o1's cdr. Otherwise, return zero. This is handy for
+/* If o1 is a cons whose cdr is a cons, return true and set o2 to
+ the o1's cdr. Otherwise, return false. This is handy for
traversing plists. */
#define PLIST_ELT_P(o1, o2) (CONSP (o1) && ((o2)=XCDR (o1), CONSP (o2)))
Fprevious_property_change which call this function with BEGIN == END.
Handle this case specially.
- If FORCE is soft (0), it's OK to return NULL. Otherwise,
+ If FORCE is soft (false), it's OK to return NULL. Otherwise,
create an interval tree for OBJECT if one doesn't exist, provided
the object actually contains text. In the current design, if there
is no text, there can be no text properties. */
-#define soft 0
-#define hard 1
+enum { soft = false, hard = true };
INTERVAL
validate_interval_range (Lisp_Object object, Lisp_Object *begin,
if (CONSP (list))
{
- bool odd_length = 0;
- Lisp_Object tail;
- for (tail = list; CONSP (tail); tail = XCDR (tail))
+ Lisp_Object tail = list;
+ do
{
- odd_length ^= 1;
+ tail = XCDR (tail);
+ if (! CONSP (tail))
+ error ("Odd length text property list");
+ tail = XCDR (tail);
QUIT;
}
- if (odd_length)
- error ("Odd length text property list");
+ while (CONSP (tail));
+
return list;
}
for (tail1 = plist; CONSP (tail1); tail1 = Fcdr (XCDR (tail1)))
{
Lisp_Object sym1 = XCAR (tail1);
- bool found = 0;
+ bool found = false;
/* Go through I's plist, looking for sym1 */
for (tail2 = i->plist; CONSP (tail2); tail2 = Fcdr (XCDR (tail2)))
if (EQ (sym1, XCAR (tail2)))
{
/* Found the same property on both lists. If the
- values are unequal, return zero. */
+ values are unequal, return false. */
if (! EQ (Fcar (XCDR (tail1)), Fcar (XCDR (tail2))))
- return 0;
+ return false;
/* Property has same value on both lists; go to next one. */
- found = 1;
+ found = true;
break;
}
if (! found)
- return 0;
+ return false;
}
- return 1;
+ return true;
}
/* Return true if the plist of interval I has any of the
/* Go through i's plist, looking for tail1 */
for (tail2 = i->plist; CONSP (tail2); tail2 = Fcdr (XCDR (tail2)))
if (EQ (sym, XCAR (tail2)))
- return 1;
+ return true;
}
- return 0;
+ return false;
}
-/* Return nonzero if the plist of interval I has any of the
+/* Return true if the plist of interval I has any of the
property names in LIST, regardless of their values. */
static bool
/* Go through i's plist, looking for tail1 */
for (tail2 = i->plist; CONSP (tail2); tail2 = XCDR (XCDR (tail2)))
if (EQ (sym, XCAR (tail2)))
- return 1;
+ return true;
}
- return 0;
+ return false;
}
\f
/* Changing the plists of individual intervals. */
enum property_set_type set_type)
{
Lisp_Object tail1, tail2, sym1, val1;
- bool changed = 0;
+ bool changed = false;
struct gcpro gcpro1, gcpro2, gcpro3;
tail1 = plist;
/* Go through each element of PLIST. */
for (tail1 = plist; CONSP (tail1); tail1 = Fcdr (XCDR (tail1)))
{
- bool found = 0;
+ bool found = false;
sym1 = XCAR (tail1);
val1 = Fcar (XCDR (tail1));
this_cdr = XCDR (tail2);
/* Found the property. Now check its value. */
- found = 1;
+ found = true;
/* The properties have the same value on both lists.
Continue to the next property. */
Fsetcar (this_cdr, list2 (Fcar (this_cdr), val1));
}
}
- changed = 1;
+ changed = true;
break;
}
sym1, Qnil, object);
}
set_interval_plist (i, Fcons (sym1, Fcons (val1, i->plist)));
- changed = 1;
+ changed = true;
}
}
static bool
remove_properties (Lisp_Object plist, Lisp_Object list, INTERVAL i, Lisp_Object object)
{
- Lisp_Object tail1, tail2, sym, current_plist;
- bool changed = 0;
+ bool changed = false;
/* True means tail1 is a plist, otherwise it is a list. */
- bool use_plist;
+ bool use_plist = ! NILP (plist);
+ Lisp_Object tail1 = use_plist ? plist : list;
- current_plist = i->plist;
-
- if (! NILP (plist))
- tail1 = plist, use_plist = 1;
- else
- tail1 = list, use_plist = 0;
+ Lisp_Object current_plist = i->plist;
/* Go through each element of LIST or PLIST. */
while (CONSP (tail1))
{
- sym = XCAR (tail1);
+ Lisp_Object sym = XCAR (tail1);
/* First, remove the symbol if it's at the head of the list */
while (CONSP (current_plist) && EQ (sym, XCAR (current_plist)))
object);
current_plist = XCDR (XCDR (current_plist));
- changed = 1;
+ changed = true;
}
/* Go through I's plist, looking for SYM. */
- tail2 = current_plist;
+ Lisp_Object tail2 = current_plist;
while (! NILP (tail2))
{
- register Lisp_Object this;
- this = XCDR (XCDR (tail2));
+ Lisp_Object this = XCDR (XCDR (tail2));
if (CONSP (this) && EQ (sym, XCAR (this)))
{
if (BUFFERP (object))
sym, XCAR (XCDR (this)), object);
Fsetcdr (XCDR (tail2), XCDR (XCDR (this)));
- changed = 1;
+ changed = true;
}
tail2 = this;
}
set_buffer_temp (XBUFFER (object));
USE_SAFE_ALLOCA;
- GET_OVERLAYS_AT (XINT (position), overlay_vec, noverlays, NULL, 0);
+ GET_OVERLAYS_AT (XINT (position), overlay_vec, noverlays, NULL, false);
noverlays = sort_overlays (overlay_vec, noverlays, w);
set_buffer_temp (obuf);
XSETFASTINT (position, ZV);
}
else
- while (1)
+ while (true)
{
position = Fnext_char_property_change (position, limit);
if (XFASTINT (position) >= XFASTINT (limit))
= Fget_char_property (make_number (XFASTINT (position) - 1),
prop, object);
- while (1)
+ while (true)
{
position = Fprevious_char_property_change (position, limit);
enum property_set_type set_type) {
INTERVAL i, unchanged;
ptrdiff_t s, len;
- bool modified = 0;
+ bool modified = false;
struct gcpro gcpro1;
- bool first_time = 1;
+ bool first_time = true;
properties = validate_plist (properties);
if (NILP (properties))
if (TOTAL_LENGTH (i) != prev_total_length
|| i->position != prev_pos)
{
- first_time = 0;
+ first_time = false;
goto retry;
}
}
{
INTERVAL i, unchanged;
ptrdiff_t s, len;
- bool modified = 0;
- bool first_time = 1;
+ bool modified = false;
+ bool first_time = true;
if (NILP (object))
XSETBUFFER (object, current_buffer);
if (TOTAL_LENGTH (i) != prev_total_length
|| i->position != prev_pos)
{
- first_time = 0;
+ first_time = false;
goto retry;
}
}
{
INTERVAL i, unchanged;
ptrdiff_t s, len;
- bool modified = 0;
+ bool modified = false;
Lisp_Object properties;
properties = list_of_properties;
}
/* We are at the beginning of an interval, with len to scan.
- The flag `modified' records if changes have been made.
+ The flag MODIFIED records if changes have been made.
When object is a buffer, we must call modify_text_properties
before changes are made and signal_after_change when we are done.
- We call modify_text_properties before calling remove_properties if modified == 0,
- and we call signal_after_change before returning if modified != 0. */
+ Call modify_text_properties before calling remove_properties if !MODIFIED,
+ and call signal_after_change before returning if MODIFIED. */
for (;;)
{
eassert (i != 0);
if (!modified && BUFFERP (object))
modify_text_properties (object, start, end);
remove_properties (Qnil, properties, i, object);
- modified = 1;
+ modified = true;
}
len -= LENGTH (i);
i = next_interval (i);
Lisp_Object stuff;
Lisp_Object plist;
ptrdiff_t s, e, e2, p, len;
- bool modified = 0;
+ bool modified = false;
struct gcpro gcpro1, gcpro2;
i = validate_interval_range (src, &start, &end, soft);
res = Fadd_text_properties (Fcar (res), Fcar (Fcdr (res)),
Fcar (Fcdr (Fcdr (res))), dest);
if (! NILP (res))
- modified = 1;
+ modified = true;
stuff = Fcdr (stuff);
}