else if (ends_with(name, "ff"))

    else if (ends_with(name, "staff"))

        // staff -> staves

        // staff -> staves, but not hippogriff -> hippogrives.

std::string thing_do_grammar(description_level_type dtype,
                             bool add_stop,
                             bool force_article,
                             std::string desc);

static std::string _feature_do_grammar(description_level_type dtype,
                                       bool add_stop,
                                       bool force_article,
                                       std::string desc)

std::string thing_do_grammar(description_level_type dtype,
                             bool add_stop,
                             bool force_article,
                             std::string desc)

    if (add_stop)

    if (add_stop && (desc.empty() || desc[desc.length() - 1] != '.'))

    return _feature_do_grammar(dtype, add_stop, grid_is_trap(grid), desc);

    return thing_do_grammar(dtype, add_stop, grid_is_trap(grid), desc);

        return _feature_do_grammar(dtype, add_stop, false, desc);

        return thing_do_grammar(dtype, add_stop, false, desc);

        return (_feature_do_grammar(

        return (thing_do_grammar(

  e.marker([[O = lua:one_way_stair { desc = "A glowing drain",
                                     dst = "sewer",
                                     dstorigin = "in the sewers",
                                     overmap = "glowing drain",
                                     floor = "stone_arch" }]])

  local timeout_turns = crawl.random_range(1500, 2000)
  local messager =
    timed_msg {
      visible = true,
      -- $F{xxx} will be substituted with the 'entity' property of the timed
      -- marker, or with the desc property (if entity is not set).
      messages = time_messages(timeout_turns,
                               "$F{The} is slowly rusting away.",
                               "$F{The} is rusting away.",
                               "$F{The} is quickly rusting away.",
                               "$F{The} is falling apart.")
    }
  e.lua_marker('O',
      timed_marker {
        desc = "glowing drain",
        entity = 'drain',
        dst = "sewer",
        dstorigin = "in the sewers",
        overmap = "glowing drain",
        turns = timeout_turns,
        floor = "stone_arch",
        msg = messager })

}}

# Use the following line in destination maps after all SUBST's have taken place
# : sewer_colours(_G)
# Note that the function also defines < to be the exit portal.
{{

-- Use the following line in destination maps after all SUBSTs
-- : sewer_colours(_G)
-- Note that the function also defines < to be the exit portal.

          scroll of blinking / scroll of identify / nothing 

          scroll of blinking / scroll of identify / nothing

: messager = bell_clock_msg { initmsg="You hear a distant snort." }

{{
  local messager = 
    timed_msg { 
      initmsg = { "You hear a distant snort.",
                  "Behold! There is an entrance to a minotaur's labyrinth "
                  .. "on this level. Find the entrance quickly before "
                  .. "the gate is sealed!" },
      finalmsg = "You hear the last, dying ticks of the clock.",
      verb = 'ticking',
      noisemaker = 'an ancient clock'
    }
}}

VISUAL:@The_monster@ breifly grows a face disturbingly similar to your own.

VISUAL:@The_monster@ briefly grows a face disturbingly similar to your own.

  local function free_space_threshold(max)
    local function is_free_space(p)
      return dgn.grid(p.x, p.y) == dgn.fnum("floor") and
        #dgn.items_at(p.x, p.y) <= max
    end
    return is_free_space
  end

end
-- Returns the sublist of elements at indices [istart, iend) of the
-- supplied list.
function util.slice(list, istart, iend)
  if not iend then
    iend = #list + 1
  end
  local res = { }
  for i = istart, iend - 1 do
    table.insert(res, list[i])
  end
  return res

function util.partition(list, slice, increment)
  local res = { }
  for i = 1, #list, increment or slice do
    table.insert(res, util.slice(list, i, i + slice))
  end
  return res
end

  local res = ""
  for i, val in ipairs(list) do
    if i > 1 then
      res = res .. sep
    end
    res = res .. val
  end
  return res

  return table.concat(list, sep)

function util.catlist(...)
  local res = { }

-- Appends the elements in any number of additional tables to the first table.
function util.append(table, ...)
  local res = table

  if #tables == 1 then

  if #tables == 0 then
    return res
  elseif #tables == 1 and #res == 0 then

end
function util.catlist(...)
  return util.append({ }, ...)

end
function util.expand_entity(entity, msg)
  return string.gsub(msg, "$F%{(%w+)%}",
                     function (desc)
                       return crawl.grammar(entity, desc)
                     end)

function TimedMessaging._new()
  local m = { }
  setmetatable(m, TimedMessaging)
  return m
end

function TimedMessaging:new(m, nocheck)
  m = m or { }
  setmetatable(m, self)
  self.__index = self

function TimedMessaging.new(pars)
  pars = pars or { }
  local m = TimedMessaging._new()
  m.noisemaker = pars.noisemaker
  m.verb       = pars.verb
  m.finalmsg   = pars.finalmsg
  m.ranges     = pars.ranges
  m.initmsg    = pars.initmsg or ''
  return m
end

  if not nocheck then
    if not m.messages then
      assert(m.noisemaker, "No noisemaker specified")
      assert(m.verb, "No verb specified")
    end

function TimedMessaging:init(tmarker, cm, verbose)
  local lab = dgn.grid(cm:pos()) == dgn.feature_number('enter_labyrinth')
  if not self.noisemaker then
    self.noisemaker = lab and "an ancient clock" or "a massive bell"

    if m.visible and not m.messages then
      error("No messages set for timer messager")
    end

  self.verb = self.verb or (lab and 'ticking' or 'tolling')

  return m
end

  if not self.finalmsg then
    self.finalmsg = lab and "last, dying ticks of the clock"
                        or  "last, dying notes of the bell"

function TimedMessaging:channel()
  if not self.sound_channel then
    self.sound_channel =
      crawl.msgch_num(self.visible and 'default' or 'sound')

  return self.sound_channel
end

  if not self.ranges then

function TimedMessaging:init(tmarker, cm, verbose)
  self.entity = tmarker.props.entity or tmarker.props.desc
  if not self.ranges and not self.visible then

  if verbose and #self.initmsg > 0 and you.hear_pos(cm:pos()) then
    crawl.mpr(self.initmsg, "sound")
    if lab then
      crawl.mpr("Behold! There is an entrance to a minotaur's labyrinth on this level. Find the entrance quickly before it seals the gate!",
                "sound")
    else
      crawl.mpr("An interdimensional caravan has stopped on this level and set up a bazaar. Hurry and find its entrance before they move on!", "sound")

  if verbose and self.initmsg then
    self:emit_message(cm, self.initmsg)
  end
end
function TimedMessaging:perceptible(cm)
  if not cm then
    return true
  end
  if self.visible then
    return you.see_grid(cm:pos())
  else
    return you.hear_pos(cm:pos())
  end
end
function TimedMessaging:emit_message(cm, msg)
  if not msg or not self:perceptible(cm) then
    return
  end
  if type(msg) == 'table' then
    util.foreach(msg,
                 function (m)
                   self:emit_message(cm, m)
                 end)
  else
    if #msg < 1 then
      return

    crawl.mpr(util.expand_entity(self.entity, msg), self:channel())

function TimedMessaging:say_message(dur)
  self.sound_channel = self.sound_channel or crawl.msgch_num('sound')
  if dur <= 0 then
    crawl.mpr("You hear the " .. self.finalmsg .. ".", self.sound_channel)

function TimedMessaging:proc_ranges(ranges, dur, fn)
  if not ranges then

  for _, chk in ipairs(self.ranges) do

  for _, chk in ipairs(ranges) do

      crawl.mpr("You hear the " .. chk[2] .. self.verb 
                .. " of " .. self.noisemaker .. ".",
                self.sound_channel)

      fn(chk, dur)

  end
end
function TimedMessaging:say_message(cm, dur)
  if dur <= 0 then
    self:emit_message(cm, self.finalmsg)
    return

  self:proc_ranges(self.ranges, dur,
                   function (chk)
                     self:emit_message(cm,
                                       "You hear the " .. chk[2] .. self.verb
                                       .. " of " .. self.noisemaker .. ".")
                   end)
  self:proc_ranges(self.messages, dur,
                   function (chk)
                     self:emit_message(cm, chk[2])
                   end)

    if you.hear_pos(cmarker:pos()) then
      self:say_message(luamark.dur)

    if self:perceptible(cmarker) then
      self:say_message(nil, luamark.dur)

  file.marshall(th, self.check)
  file.marshall(th, self.noisemaker)
  file.marshall(th, self.verb)
  file.marshall(th, self.initmsg)
  file.marshall(th, self.finalmsg)
  lmark.marshall_table(th, self.ranges)

  lmark.marshall_table(th, self)

  local tm = TimedMessaging._new()
  tm.check = file.unmarshall_number(th)
  tm.noisemaker = file.unmarshall_string(th)
  tm.verb = file.unmarshall_string(th)
  tm.initmsg = file.unmarshall_string(th)
  tm.finalmsg = file.unmarshall_string(th)
  tm.ranges = lmark.unmarshall_table(th)
  return tm

  return TimedMessaging:new(lmark.unmarshall_table(th))
end
function timed_msg(pars)
  return TimedMessaging:new(pars)

function bell_clock_msg(pars)
  return TimedMessaging.new(pars)

-- Accepts pairs of turns and messages used for a timer. For instance
-- timer_interval_messages(500, 'You feel vaguely uneasy.',
--                         250, 'You feel extremely uneasy.',
--                         100, 'You feel a primal terror.')
-- Will produce the first message when the timer has > 500 turns, the
-- second message when the timer has <= 500 turns and >250 turns, and so on.
-- Note that any given interval message will be repeated, usually every 50
-- or 25 turns.
function timer_interval_messages(...)
  local breakpoints = util.partition({ ... }, 2)
  -- Expand turn breakpoints into tenths of a turn.
  util.foreach(breakpoints,
               function (brk)
                 brk[1] = brk[1] * 10
               end)
  return breakpoints

-- Accepts timer messages as with timer_interval_messages, but with no
-- explicit intervals. Instead, the total turn count is divided by the
-- number of messages to determine intervals.
function time_messages(total_turns, ...)
  local messages = { ... }
  local n = #messages
  -- Each interval is 1.2 * the previous (lower) interval.
  local inflate = 1.2
  local function power_sum(n)
    local sum = 1
    for i = 1, n - 1 do
      sum = sum + inflate ^ i
    end
    return sum
  end
  local base_interval = total_turns / power_sum(n)
  local res = { }
  for i = 1, n - 1 do
    local pow = n - i
    total_turns = total_turns - base_interval * inflate ^ pow
    table.insert(res, { math.floor(10 * total_turns), messages[i] } )
  end
  table.insert(res, { 0, messages[n] })
  return res
end

end

end

end
function PortalDescriptor:unmangle(x)
  if x and type(x) == 'function' then
    return x(self)
  else
    return x
  end

  return self.props.desc

  return self:unmangle(self.props.desc)

  return self.props and self.props[pname] or ''

  return self:unmangle(self.props and self.props[pname] or '')

  local messager = bell_clock_msg { initmsg="You hear coins being counted." }

  local messager =
    timed_msg {
      initmsg = { "You hear coins being counted.",
                  "An interdimensional caravan has stopped on this level "
                  .. "and set up a bazaar. Hurry and find its entrance before "
                  .. "they move on!" },
      finalmsg = "You hear the last, dying notes of the bell.",
      verb = 'tolling',
      noisemaker = 'a massive bell'
    }

static int _crawl_grammar(lua_State *ls)
{
    description_level_type ndesc = DESC_PLAIN;
    if (lua_isstring(ls, 2))
        ndesc = description_type_by_name(lua_tostring(ls, 2));
    PLUARET(string,
            thing_do_grammar(ndesc, false,
                             false, luaL_checkstring(ls, 1)).c_str());
}

    { "grammar",        _crawl_grammar },