libs/core/luasrc/util.lua

   1 --[[
   2 LuCI - Utility library
   3
   4 Description:
   5 Several common useful Lua functions
   6
   7 FileId:
   8 $Id$
   9
  10 License:
  11 Copyright 2008 Steven Barth <steven@midlink.org>
  12
  13 Licensed under the Apache License, Version 2.0 (the "License");
  14 you may not use this file except in compliance with the License.
  15 You may obtain a copy of the License at
  16
  17         http://www.apache.org/licenses/LICENSE-2.0
  18
  19 Unless required by applicable law or agreed to in writing, software
  20 distributed under the License is distributed on an "AS IS" BASIS,
  21 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  22 See the License for the specific language governing permissions and
  23 limitations under the License.
  24
  25 ]]--
  26
  27 local io = require "io"
  28 local math = require "math"
  29 local table = require "table"
  30 local debug = require "debug"
  31 local ldebug = require "luci.debug"
  32 local string = require "string"
  33 local coroutine = require "coroutine"
  34
  35 local getmetatable, setmetatable = getmetatable, setmetatable
  36 local rawget, rawset, unpack = rawget, rawset, unpack
  37 local tostring, type, assert = tostring, type, assert
  38 local ipairs, pairs, loadstring = ipairs, pairs, loadstring
  39 local require, pcall, xpcall = require, pcall, xpcall
  40
  41 --- LuCI utility functions.
  42 module "luci.util"
  43
  44 --
  45 -- Pythonic string formatting extension
  46 --
  47 getmetatable("").__mod = function(a, b)
  48         if not b then
  49                 return a
  50         elseif type(b) == "table" then
  51                 return a:format(unpack(b))
  52         else
  53                 return a:format(b)
  54         end
  55 end
  56
  57
  58 --
  59 -- Class helper routines
  60 --
  61
  62 -- Instantiates a class
  63 local function _instantiate(class, ...)
  64         local inst = setmetatable({}, {__index = class})
  65
  66         if inst.__init__ then
  67                 inst:__init__(...)
  68         end
  69
  70         return inst
  71 end
  72
  73 --- Create a Class object (Python-style object model).
  74 -- The class object can be instantiated by calling itself.
  75 -- Any class functions or shared parameters can be attached to this object.
  76 -- Attaching a table to the class object makes this table shared between
  77 -- all instances of this class. For object parameters use the __init__ function.
  78 -- Classes can inherit member functions and values from a base class.
  79 -- Class can be instantiated by calling them. All parameters will be passed
  80 -- to the __init__ function of this class - if such a function exists.
  81 -- The __init__ function must be used to set any object parameters that are not shared
  82 -- with other objects of this class. Any return values will be ignored.
  83 -- @param base  The base class to inherit from (optional)
  84 -- @return              A class object
  85 -- @see                 instanceof
  86 -- @see                 clone
  87 function class(base)
  88         return setmetatable({}, {
  89                 __call  = _instantiate,
  90                 __index = base
  91         })
  92 end
  93
  94 --- Test whether the given object is an instance of the given class.
  95 -- @param object        Object instance
  96 -- @param class         Class object to test against
  97 -- @return                      Boolean indicating whether the object is an instance
  98 -- @see                         class
  99 -- @see                         clone
 100 function instanceof(object, class)
 101         local meta = getmetatable(object)
 102         while meta and meta.__index do
 103                 if meta.__index == class then
 104                         return true
 105                 end
 106                 meta = getmetatable(meta.__index)
 107         end
 108         return false
 109 end
 110
 111
 112 --
 113 -- Scope manipulation routines
 114 --
 115
 116 --- Create a new or get an already existing thread local store associated with
 117 -- the current active coroutine. A thread local store is private a table object
 118 -- whose values can't be accessed from outside of the running coroutine.
 119 -- @return      Table value representing the corresponding thread local store
 120 function threadlocal()
 121         local tbl = {}
 122
 123         local function get(self, key)
 124                 local c = coroutine.running()
 125                 local thread = coxpt[c] or c or 0
 126                 if not rawget(self, thread) then
 127                         return nil
 128                 end
 129                 return rawget(self, thread)[key]
 130         end
 131
 132         local function set(self, key, value)
 133                 local c = coroutine.running()
 134                 local thread = coxpt[c] or c or 0
 135                 if not rawget(self, thread) then
 136                         rawset(self, thread, {})
 137                 end
 138                 rawget(self, thread)[key] = value
 139         end
 140
 141         setmetatable(tbl, {__index = get, __newindex = set, __mode = "k"})
 142
 143         return tbl
 144 end
 145
 146
 147 --
 148 -- Debugging routines
 149 --
 150
 151 --- Write given object to stderr.
 152 -- @param obj   Value to write to stderr
 153 -- @return              Boolean indicating whether the write operation was successful
 154 function perror(obj)
 155         return io.stderr:write(tostring(obj) .. "\n")
 156 end
 157
 158 --- Recursively dumps a table to stdout, useful for testing and debugging.
 159 -- @param t     Table value to dump
 160 -- @param maxdepth      Maximum depth
 161 -- @return      Always nil
 162 function dumptable(t, maxdepth, i, seen)
 163         i = i or 0
 164         seen = seen or setmetatable({}, {__mode="k"})
 165
 166         for k,v in pairs(t) do
 167                 perror(string.rep("\t", i) .. tostring(k) .. "\t" .. tostring(v))
 168                 if type(v) == "table" and (not maxdepth or i < maxdepth) then
 169                         if not seen[v] then
 170                                 seen[v] = true
 171                                 dumptable(v, maxdepth, i+1, seen)
 172                         else
 173                                 perror(string.rep("\t", i) .. "*** RECURSION ***")
 174                         end
 175                 end
 176         end
 177 end
 178
 179
 180 --
 181 -- String and data manipulation routines
 182 --
 183
 184 --- Escapes all occurrences of the given character in given string.
 185 -- @param s     String value containing unescaped characters
 186 -- @param c     String value with character to escape (optional, defaults to "\")
 187 -- @return      String value with each occurrence of character escaped with "\"
 188 function escape(s, c)
 189         c = c or "\\"
 190         return s:gsub(c, "\\" .. c)
 191 end
 192
 193 --- Create valid XML PCDATA from given string.
 194 -- @param value String value containing the data to escape
 195 -- @return              String value containing the escaped data
 196 function pcdata(value)
 197         return value and tostring(value):gsub("[&\"'<>]", {
 198                 ["&"] = "&#38;",
 199                 ['"'] = "&#34;",
 200                 ["'"] = "&#39;",
 201                 ["<"] = "&#60;",
 202                 [">"] = "&#62;"
 203         })
 204 end
 205
 206 --- Strip HTML tags from given string.
 207 -- @param value String containing the HTML text
 208 -- @return      String with HTML tags stripped of
 209 function striptags(s)
 210         return pcdata(s:gsub("</?[A-Za-z][A-Za-z0-9:_%-]*[^>]*>", " "):gsub("%s+", " "))
 211 end
 212
 213 --- Splits given string on a defined separator sequence and return a table
 214 -- containing the resulting substrings. The optional max parameter specifies
 215 -- the number of bytes to process, regardless of the actual length of the given
 216 -- string. The optional last parameter, regex, specifies whether the separator
 217 -- sequence is interpreted as regular expression.
 218 -- @param str           String value containing the data to split up
 219 -- @param pat           String with separator pattern (optional, defaults to "\n")
 220 -- @param max           Maximum times to split (optional)
 221 -- @param regex         Boolean indicating whether to interpret the separator
 222 --                                      pattern as regular expression (optional, default is false)
 223 -- @return                      Table containing the resulting substrings
 224 function split(str, pat, max, regex)
 225         pat = pat or "\n"
 226         max = max or #str
 227
 228         local t = {}
 229         local c = 1
 230
 231         if #str == 0 then
 232                 return {""}
 233         end
 234
 235         if #pat == 0 then
 236                 return nil
 237         end
 238
 239         if max == 0 then
 240                 return str
 241         end
 242
 243         repeat
 244                 local s, e = str:find(pat, c, not regex)
 245                 max = max - 1
 246                 if s and max < 0 then
 247                         t[#t+1] = str:sub(c)
 248                 else
 249                         t[#t+1] = str:sub(c, s and s - 1)
 250                 end
 251                 c = e and e + 1 or #str + 1
 252         until not s or max < 0
 253
 254         return t
 255 end
 256
 257 --- Remove leading and trailing whitespace from given string value.
 258 -- @param str   String value containing whitespace padded data
 259 -- @return              String value with leading and trailing space removed
 260 function trim(str)
 261         return (str:gsub("^%s*(.-)%s*$", "%1"))
 262 end
 263
 264 --- Parse certain units from the given string and return the canonical integer
 265 -- value or 0 if the unit is unknown. Upper- or lower case is irrelevant.
 266 -- Recognized units are:
 267 --      o "y"   - one year   (60*60*24*366)
 268 --  o "m"       - one month  (60*60*24*31)
 269 --  o "w"       - one week   (60*60*24*7)
 270 --  o "d"       - one day    (60*60*24)
 271 --  o "h"       - one hour       (60*60)
 272 --  o "min"     - one minute (60)
 273 --  o "kb"  - one kilobyte (1024)
 274 --  o "mb"      - one megabyte (1024*1024)
 275 --  o "gb"      - one gigabyte (1024*1024*1024)
 276 --  o "kib" - one si kilobyte (1000)
 277 --  o "mib"     - one si megabyte (1000*1000)
 278 --  o "gib"     - one si gigabyte (1000*1000*1000)
 279 -- @param ustr  String containing a numerical value with trailing unit
 280 -- @return              Number containing the canonical value
 281 function parse_units(ustr)
 282
 283         local val = 0
 284
 285         -- unit map
 286         local map = {
 287                 -- date stuff
 288                 y   = 60 * 60 * 24 * 366,
 289                 m   = 60 * 60 * 24 * 31,
 290                 w   = 60 * 60 * 24 * 7,
 291                 d   = 60 * 60 * 24,
 292                 h   = 60 * 60,
 293                 min = 60,
 294
 295                 -- storage sizes
 296                 kb  = 1024,
 297                 mb  = 1024 * 1024,
 298                 gb  = 1024 * 1024 * 1024,
 299
 300                 -- storage sizes (si)
 301                 kib = 1000,
 302                 mib = 1000 * 1000,
 303                 gib = 1000 * 1000 * 1000
 304         }
 305
 306         -- parse input string
 307         for spec in ustr:lower():gmatch("[0-9%.]+[a-zA-Z]*") do
 308
 309                 local num = spec:gsub("[^0-9%.]+$","")
 310                 local spn = spec:gsub("^[0-9%.]+", "")
 311
 312                 if map[spn] or map[spn:sub(1,1)] then
 313                         val = val + num * ( map[spn] or map[spn:sub(1,1)] )
 314                 else
 315                         val = val + num
 316                 end
 317         end
 318
 319
 320         return val
 321 end
 322
 323 --- Combines two or more numerically indexed tables into one.
 324 -- @param tbl1  Table value to combine
 325 -- @param tbl2  Table value to combine
 326 -- @param ...   More tables to combine
 327 -- @return              Table value containing all values of given tables
 328 function combine(...)
 329         local result = {}
 330         for i, a in ipairs(arg) do
 331                 for j, v in ipairs(a) do
 332                         result[#result+1] = v
 333                 end
 334         end
 335         return result
 336 end
 337
 338 --- Checks whether the given table contains the given value.
 339 -- @param table Table value
 340 -- @param value Value to search within the given table
 341 -- @return              Boolean indicating whether the given value occurs within table
 342 function contains(table, value)
 343         for k, v in pairs(table) do
 344                 if value == v then
 345                         return k
 346                 end
 347         end
 348         return false
 349 end
 350
 351 --- Update values in given table with the values from the second given table.
 352 -- Both table are - in fact - merged together.
 353 -- @param t                     Table which should be updated
 354 -- @param updates       Table containing the values to update
 355 -- @return                      Always nil
 356 function update(t, updates)
 357         for k, v in pairs(updates) do
 358                 t[k] = v
 359         end
 360 end
 361
 362 --- Retrieve all keys of given associative table.
 363 -- @param t     Table to extract keys from
 364 -- @return      Sorted table containing the keys
 365 function keys(t)
 366         local keys = { }
 367         if t then
 368                 for k, _ in kspairs(t) do
 369                         keys[#keys+1] = k
 370                 end
 371         end
 372         return keys
 373 end
 374
 375 --- Clones the given object and return it's copy.
 376 -- @param object        Table value to clone
 377 -- @param deep          Boolean indicating whether to do recursive cloning
 378 -- @return                      Cloned table value
 379 function clone(object, deep)
 380         local copy = {}
 381
 382         for k, v in pairs(object) do
 383                 if deep and type(v) == "table" then
 384                         v = clone(v, deep)
 385                 end
 386                 copy[k] = v
 387         end
 388
 389         return setmetatable(copy, getmetatable(object))
 390 end
 391
 392
 393 --- Create a dynamic table which automatically creates subtables.
 394 -- @return      Dynamic Table
 395 function dtable()
 396         return setmetatable({}, { __index =
 397                 function(tbl, key)
 398                         return rawget(tbl, key)
 399                          or rawget(rawset(tbl, key, dtable()), key)
 400                 end
 401         })
 402 end
 403
 404
 405 -- Serialize the contents of a table value.
 406 function _serialize_table(t, seen)
 407         assert(not seen[t], "Recursion detected.")
 408         seen[t] = true
 409
 410         local data  = ""
 411         local idata = ""
 412         local ilen  = 0
 413
 414         for k, v in pairs(t) do
 415                 if type(k) ~= "number" or k < 1 or math.floor(k) ~= k or ( k - #t ) > 3 then
 416                         k = serialize_data(k, seen)
 417                         v = serialize_data(v, seen)
 418                         data = data .. ( #data > 0 and ", " or "" ) ..
 419                                 '[' .. k .. '] = ' .. v
 420                 elseif k > ilen then
 421                         ilen = k
 422                 end
 423         end
 424
 425         for i = 1, ilen do
 426                 local v = serialize_data(t[i], seen)
 427                 idata = idata .. ( #idata > 0 and ", " or "" ) .. v
 428         end
 429
 430         return idata .. ( #data > 0 and #idata > 0 and ", " or "" ) .. data
 431 end
 432
 433 --- Recursively serialize given data to lua code, suitable for restoring
 434 -- with loadstring().
 435 -- @param val   Value containing the data to serialize
 436 -- @return              String value containing the serialized code
 437 -- @see                 restore_data
 438 -- @see                 get_bytecode
 439 function serialize_data(val, seen)
 440         seen = seen or setmetatable({}, {__mode="k"})
 441
 442         if val == nil then
 443                 return "nil"
 444         elseif type(val) == "number" then
 445                 return val
 446         elseif type(val) == "string" then
 447                 return "%q" % val
 448         elseif type(val) == "boolean" then
 449                 return val and "true" or "false"
 450         elseif type(val) == "function" then
 451                 return "loadstring(%q)" % get_bytecode(val)
 452         elseif type(val) == "table" then
 453                 return "{ " .. _serialize_table(val, seen) .. " }"
 454         else
 455                 return '"[unhandled data type:' .. type(val) .. ']"'
 456         end
 457 end
 458
 459 --- Restore data previously serialized with serialize_data().
 460 -- @param str   String containing the data to restore
 461 -- @return              Value containing the restored data structure
 462 -- @see                 serialize_data
 463 -- @see                 get_bytecode
 464 function restore_data(str)
 465         return loadstring("return " .. str)()
 466 end
 467
 468
 469 --
 470 -- Byte code manipulation routines
 471 --
 472
 473 --- Return the current runtime bytecode of the given data. The byte code
 474 -- will be stripped before it is returned.
 475 -- @param val   Value to return as bytecode
 476 -- @return              String value containing the bytecode of the given data
 477 function get_bytecode(val)
 478         local code
 479
 480         if type(val) == "function" then
 481                 code = string.dump(val)
 482         else
 483                 code = string.dump( loadstring( "return " .. serialize_data(val) ) )
 484         end
 485
 486         return code and strip_bytecode(code)
 487 end
 488
 489 --- Strips unnescessary lua bytecode from given string. Information like line
 490 -- numbers and debugging numbers will be discarded. Original version by
 491 -- Peter Cawley (http://lua-users.org/lists/lua-l/2008-02/msg01158.html)
 492 -- @param code  String value containing the original lua byte code
 493 -- @return              String value containing the stripped lua byte code
 494 function strip_bytecode(code)
 495         local version, format, endian, int, size, ins, num, lnum = code:byte(5, 12)
 496         local subint
 497         if endian == 1 then
 498                 subint = function(code, i, l)
 499                         local val = 0
 500                         for n = l, 1, -1 do
 501                                 val = val * 256 + code:byte(i + n - 1)
 502                         end
 503                         return val, i + l
 504                 end
 505         else
 506                 subint = function(code, i, l)
 507                         local val = 0
 508                         for n = 1, l, 1 do
 509                                 val = val * 256 + code:byte(i + n - 1)
 510                         end
 511                         return val, i + l
 512                 end
 513         end
 514
 515         local strip_function
 516         strip_function = function(code)
 517                 local count, offset = subint(code, 1, size)
 518                 local stripped, dirty = string.rep("\0", size), offset + count
 519                 offset = offset + count + int * 2 + 4
 520                 offset = offset + int + subint(code, offset, int) * ins
 521                 count, offset = subint(code, offset, int)
 522                 for n = 1, count do
 523                         local t
 524                         t, offset = subint(code, offset, 1)
 525                         if t == 1 then
 526                                 offset = offset + 1
 527                         elseif t == 4 then
 528                                 offset = offset + size + subint(code, offset, size)
 529                         elseif t == 3 then
 530                                 offset = offset + num
 531                         elseif t == 254 or t == 9 then
 532                                 offset = offset + lnum
 533                         end
 534                 end
 535                 count, offset = subint(code, offset, int)
 536                 stripped = stripped .. code:sub(dirty, offset - 1)
 537                 for n = 1, count do
 538                         local proto, off = strip_function(code:sub(offset, -1))
 539                         stripped, offset = stripped .. proto, offset + off - 1
 540                 end
 541                 offset = offset + subint(code, offset, int) * int + int
 542                 count, offset = subint(code, offset, int)
 543                 for n = 1, count do
 544                         offset = offset + subint(code, offset, size) + size + int * 2
 545                 end
 546                 count, offset = subint(code, offset, int)
 547                 for n = 1, count do
 548                         offset = offset + subint(code, offset, size) + size
 549                 end
 550                 stripped = stripped .. string.rep("\0", int * 3)
 551                 return stripped, offset
 552         end
 553
 554         return code:sub(1,12) .. strip_function(code:sub(13,-1))
 555 end
 556
 557
 558 --
 559 -- Sorting iterator functions
 560 --
 561
 562 function _sortiter( t, f )
 563         local keys = { }
 564
 565         for k, v in pairs(t) do
 566                 keys[#keys+1] = k
 567         end
 568
 569         local _pos = 0
 570
 571         table.sort( keys, f )
 572
 573         return function()
 574                 _pos = _pos + 1
 575                 if _pos <= #keys then
 576                         return keys[_pos], t[keys[_pos]]
 577                 end
 578         end
 579 end
 580
 581 --- Return a key, value iterator which returns the values sorted according to
 582 -- the provided callback function.
 583 -- @param t     The table to iterate
 584 -- @param f A callback function to decide the order of elements
 585 -- @return      Function value containing the corresponding iterator
 586 function spairs(t,f)
 587         return _sortiter( t, f )
 588 end
 589
 590 --- Return a key, value iterator for the given table.
 591 -- The table pairs are sorted by key.
 592 -- @param t     The table to iterate
 593 -- @return      Function value containing the corresponding iterator
 594 function kspairs(t)
 595         return _sortiter( t )
 596 end
 597
 598 --- Return a key, value iterator for the given table.
 599 -- The table pairs are sorted by value.
 600 -- @param t     The table to iterate
 601 -- @return      Function value containing the corresponding iterator
 602 function vspairs(t)
 603         return _sortiter( t, function (a,b) return t[a] < t[b] end )
 604 end
 605
 606
 607 --
 608 -- System utility functions
 609 --
 610
 611 --- Test whether the current system is operating in big endian mode.
 612 -- @return      Boolean value indicating whether system is big endian
 613 function bigendian()
 614         return string.byte(string.dump(function() end), 7) == 0
 615 end
 616
 617 --- Execute given commandline and gather stdout.
 618 -- @param command       String containing command to execute
 619 -- @return                      String containing the command's stdout
 620 function exec(command)
 621         local pp   = io.popen(command)
 622         local data = pp:read("*a")
 623         pp:close()
 624
 625         return data
 626 end
 627
 628 --- Return a line-buffered iterator over the output of given command.
 629 -- @param command       String containing the command to execute
 630 -- @return                      Iterator
 631 function execi(command)
 632         local pp = io.popen(command)
 633
 634         return pp and function()
 635                 local line = pp:read()
 636
 637                 if not line then
 638                         pp:close()
 639                 end
 640
 641                 return line
 642         end
 643 end
 644
 645 -- Deprecated
 646 function execl(command)
 647         local pp   = io.popen(command)
 648         local line = ""
 649         local data = {}
 650
 651         while true do
 652                 line = pp:read()
 653                 if (line == nil) then break end
 654                 data[#data+1] = line
 655         end
 656         pp:close()
 657
 658         return data
 659 end
 660
 661 --- Returns the absolute path to LuCI base directory.
 662 -- @return              String containing the directory path
 663 function libpath()
 664         return require "luci.fs".dirname(ldebug.__file__)
 665 end
 666
 667
 668 --
 669 -- Coroutine safe xpcall and pcall versions modified for Luci
 670 -- original version:
 671 -- coxpcall 1.13 - Copyright 2005 - Kepler Project (www.keplerproject.org)
 672 --
 673 -- Copyright © 2005 Kepler Project.
 674 -- Permission is hereby granted, free of charge, to any person obtaining a
 675 -- copy of this software and associated documentation files (the "Software"),
 676 -- to deal in the Software without restriction, including without limitation
 677 -- the rights to use, copy, modify, merge, publish, distribute, sublicense,
 678 -- and/or sell copies of the Software, and to permit persons to whom the
 679 -- Software is furnished to do so, subject to the following conditions:
 680 --
 681 -- The above copyright notice and this permission notice shall be
 682 -- included in all copies or substantial portions of the Software.
 683 --
 684 -- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 685 -- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 686 -- OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 687 -- IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 688 -- DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 689 -- TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
 690 -- OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 691
 692 local performResume, handleReturnValue
 693 local oldpcall, oldxpcall = pcall, xpcall
 694 coxpt = {}
 695 setmetatable(coxpt, {__mode = "kv"})
 696
 697 -- Identity function for copcall
 698 local function copcall_id(trace, ...)
 699   return ...
 700 end
 701
 702 --- This is a coroutine-safe drop-in replacement for Lua's "xpcall"-function
 703 -- @param f             Lua function to be called protected
 704 -- @param err   Custom error handler
 705 -- @param ...   Parameters passed to the function
 706 -- @return              A boolean whether the function call succeeded and the return
 707 --                              values of either the function or the error handler
 708 function coxpcall(f, err, ...)
 709         local res, co = oldpcall(coroutine.create, f)
 710         if not res then
 711                 local params = {...}
 712                 local newf = function() return f(unpack(params)) end
 713                 co = coroutine.create(newf)
 714         end
 715         local c = coroutine.running()
 716         coxpt[co] = coxpt[c] or c or 0
 717
 718         return performResume(err, co, ...)
 719 end
 720
 721 --- This is a coroutine-safe drop-in replacement for Lua's "pcall"-function
 722 -- @param f             Lua function to be called protected
 723 -- @param ...   Parameters passed to the function
 724 -- @return              A boolean whether the function call succeeded and the returns
 725 --                              values of the function or the error object
 726 function copcall(f, ...)
 727         return coxpcall(f, copcall_id, ...)
 728 end
 729
 730 -- Handle return value of protected call
 731 function handleReturnValue(err, co, status, ...)
 732         if not status then
 733                 return false, err(debug.traceback(co, (...)), ...)
 734         end
 735         if coroutine.status(co) == 'suspended' then
 736                 return performResume(err, co, coroutine.yield(...))
 737         else
 738                 return true, ...
 739         end
 740 end
 741
 742 -- Resume execution of protected function call
 743 function performResume(err, co, ...)
 744         return handleReturnValue(err, co, coroutine.resume(co, ...))
 745 end