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