libqirt/std.qi

func Object(t, p=nil, o={}): return p !is nil? set_meta_table(p, get_meta_table(p) + t): set_meta_table(o, t)
func is_object(o): return has_meta_table(o)
func __class_wrapper(n, p, t, mt, st): return Object({
    "t": t,
    "mt": mt,
    "super": p,
    "__type": func (this) use (n): return n,
    "__str": func (this) use (n): return "<class " + n + ">",
    "__call": func (this, pargs) use (n, p) {
        var t = {}
        var mt = { "__type": func (this) use (n): n }
        if p {
          var i = 0
          for i < len(p) {
            t += p[i].t
            mt += p[i].mt

            i += 1
          }
        }
        t += this.t
        mt += this.mt
        mt.super = this.super
        var obj = set_meta_table(t, mt)
        if "constructor" in mt
          func_call(mt.constructor, [obj] + pargs)
        return obj
    }
}, nil, st)
class Error {
  msg = nil

  constructor (this, msg=nil) {
    this.msg = msg
  }

  __str (this): this.msg is nil? type(this): type(this) + ": " + this.msg
}
class AssertionError(Error)
class TypeError(Error)
class ValueError(Error)
class IndexError(Error)
class KeyError(Error)
class RecursionError(Error)
class NameError(Error)
class IOError(Error)
func isinstance(a, b): return type(a) == type(b)
func head(l): return l[0]
func tail(l): return slice(l, 1)
func min(x, y): x < y? x: y
func max(x, y): x > y? x: y
func reverse(x) {
  if type(x) !in ("list", "string", "bytes")
    throw TypeError("expected first argument to be: list, string or bytes, but got: " + type(x))
  var r = []
  for var i = len(x)-1; i >= 0; i--
    list_push(r, x[i])
  if type(x) == "string"
    return list_join(r)
  elif type(x) == "bytes"
    return bytes(r)
  return r
}
set_pseudomethod("list.reverse", reverse)
set_pseudomethod("string.reverse", reverse)
set_pseudomethod("bytes.reverse", reverse)
func range(f) {
  var t, s
  if len(arguments) >= 3 {
    t = arguments[1]
    s = arguments[2]
  } elif len(arguments) >= 2 {
    t = arguments[1]
    s = 1
  } else {
    t = f
    f = 0
    s = 1
  }
  if type(f) != "number"
    throw TypeError("expected first argument to be: number, but got: " + type(f))
  if type(t) != "number"
    throw TypeError("expected second argument to be: number, but got: " + type(t))
  if type(s) != "number"
    throw TypeError("expected third argument to be: number, but got: " + type(s))
  if f > t
    return reverse(range(t, f, s))
  var r = []
  for var i = f; i < t; i += s
    list_push(r, i)
  return r
}
let SEEK_SET = 0, SEEK_CUR = 1, SEEK_END = 2
func frewind(file)
  return file.rewind()
func read_stdin() {
  return str(fread(STDIN, -1))
}
func file_read(filename) {
  let file = fopen(filename, "r")
  defer fclose(file)
  return str(fread(file, -1))
}
func file_write(filename, data) {
  let file = fopen(filename, "w")
  defer fclose(file)
  fwrite(file, bytes(data))
}
func is_defined(name) {
  if type(name) != "string"
    throw TypeError("expected first argument to be: string, but got: " + type(name))
  inline `qi_bool b = qi_find(state, qi_get(state, "name")->value.string) != NULL`
  inline `return qi_make_boolean(state, b)`
}
func is_table(a) {
  inline `return qi_make_boolean(state, qi_get(state, "a")->type == QI_TABLE)`
}
func list_remove(l, x, first=false) {
  if type(l) != "list"
    throw TypeError("expected first argument to be: list, but got: " + type(l))
  repeat:
  for var i = 0; i < len(l); i++
    if l[i] == x {
      list_delete(l, i)
      if first
        break
      goto repeat
    }
}
set_pseudomethod("list.remove", list_remove)
func list_join(l) {
  if type(l) != "list"
    throw TypeError("expected first argumient to be: list, but got: " + type(l))
  var r = ""
  var s
  if len(arguments) == 1
    s = ""
  else
    s = arguments[1]
  if type(s) != "string"
    throw TypeError("expected second argument to be: string, but got: " + type(s))
  var first = true
  for var x of l {
    if type(x) != "string"
      throw TypeError("expected sequence item to be: string, but got: " + type(x))
    if s != "" && !first
      r += s
    r += x
    first = false
  }
  return r
}
set_pseudomethod("list.join", list_join)
func list_pop_at(l, i) {
  if type(l) != "list"
    throw TypeError("expected first argument to be: list, but got: " + type(l))
  if type(i) != "number"
    throw TypeError("expected second argument to be: number, but got: " + type(i))
  var x = l[i]
  list_delete(l, i)
  return x
}
set_pseudomethod("list.popAt", list_pop_at)
func __cmp(x, y): x > y? 1: x < y? -1: 0
func list_sort(l, cmp=__cmp) {
  if type(l) != "list"
    throw TypeError("expected first argument to be: list, but got: " + type(l))
  if type(cmp) != "function"
    throw TypeError("expected second argument to be: function, but got: " + type(cmp))
  if len(l) == 0
    return l
  var z = len(l)
  for var i = 0; i < z - 1; i++
    for var j = 0; j < z - 1 - i; j++
      if cmp(l[j], l[j+1]) > 0 {
        let tmp = l[j]
        l[j] = l[j+1]
        l[j+1] = tmp
      }
  return l
}
func list_sorted(l, cmp=__cmp) {
  l = list_copy(l)
  return list_sort(l, cmp)
}
set_pseudomethod("list.sort", list_sort)
set_pseudomethod("list.sorted", list_sorted)
func list_shift(l) {
  if type(l) != "list"
    throw TypeError("expected first argument to be: list, but got: " + type(l))
  if is_empty(l)
    throw IndexError("shift from empty list")
  var a = l[0]
  list_delete(l, 0)
  return a
}
func list_unshift(l, x) {
  list_insert(l, 0, x)
}
set_pseudomethod("list.shift", list_shift)
set_pseudomethod("list.unshift", list_unshift)
set_pseudomethod("list.insert", list_insert)
set_pseudomethod("list.delete", list_delete)
func slice(l) {
  if type(l) !in ("list", "string", "bytes", "ustr")
    throw TypeError("expected first argument to be: list, string, bytes or ustr, but got: " + type(l))
  var r = []
  if len(arguments) == 2 {
    var f = arguments[1]
    if type(f) != "number"
      throw TypeError("expected second argument to be: number, but got: " + type(f))
    if f < 0
      f += len(l)
    for var i = f; i < len(l); i++
      list_push(r, l[i])
  } elif len(arguments) == 3 {
    var f = arguments[1], t = arguments[2]
    if type(f) != "number"
      throw TypeError("expected second argument to be: number, but got: " + type(f))
    if type(t) != "number"
      throw TypeError("expected third argument to be: number, but got: " + type(t))
    if f < 0
      f += len(l)
    if t < 0
      t += len(l)
    for var i = f; i < len(l) && i <= t; i++
      list_push(r, l[i])
  }
  if type(l) == "string"
    return list_join(r)
  elif type(l) == "bytes"
    return bytes(r)
  elif type(l) == "ustr"
    return ustr(r)
  return r
}
set_pseudomethod("list.slice", slice)
set_pseudomethod("string.slice", slice)
set_pseudomethod("bytes.slice", slice)
let __slice = slice;
func str_startswith(s, p) {
  if type(s) != "string"
    throw TypeError("expected first argument to be: string, but got: " + type(s))
  if len(s) < len(p)
    return false
  return slice(s, 0, len(p)-1) == p
}
set_pseudomethod("string.startsWith", str_startswith)
func str_endswith(s, p) {
  if type(s) != "string"
    throw TypeError("expected first argument to be: string, but got: " + type(s))
  if len(s) < len(p)
    return false
  return slice(s, len(s) - len(p)) == p
}
set_pseudomethod("string.endsWith", str_endswith)
func str_split(s) {
  if len(arguments) == 1 || arguments[1] == ""
    return list(s)
  if type(s) != "string"
    throw TypeError("expected first argument to be:!string, but got: " + type(s))
  var r = []
  var d = arguments[1]
  if type(d) != "string"
    throw TypeError("expected second argument to be: string, but got: " + type(s))
  var t = ""
  for var i = 0; i < len(s); i++ {
    if slice(s, i, i+len(d)-1) == d {
      list_push(r, t)
      t = ""
      i += len(d)-1
      continue
    }
    t += s[i]
  }
  if t != ""
    list_push(r, t)
  return r
}
set_pseudomethod("string.split", str_split)
func str_replace(s, w, b) {
  if type(s) != "string"
    throw TypeError("expected first argument to be: string, but got: " + type(s))
  if type(w) != "string"
    throw TypeError("expected second argument to be: string, but got: " + type(w))
  if type(b) != "string"
    throw TypeError("expected third argument to be: string, but got: " + type(b))
  var r = ""
  for var i = 0; i < len(s); i++ {
    if slice(s, i, i+len(w)-1) == w {
      r += b
      i += len(w)-1
      continue
    }
    r += s[i]
  }
  return r
}
set_pseudomethod("string.replace", str_replace)
func table_keys(t) {
  if type(t) != "table"
    throw TypeError("expected first argument to be: table, but got: " + type(t))
  var r = []
  for var k of t
    list_push(r, k)
  return r
}
set_pseudomethod("table.keys", table_keys)
func table_values(t) {
  if type(t) != "table"
    throw TypeError("expected first argument to be: table, but got: " + type(t))
  var r = []
  for var k of t
    list_push(r, t[k])
  return r
}
set_pseudomethod("table.values", table_values)
func reduce(f, xs) {
  if type(f) != "function"
    throw TypeError("expected first argument to be: function, but got: " + type(f))
  if type(xs) !in ("list", "tuple", "string", "bytes")
    throw TypeError("expected second argument to be: list, tuple, string or bytes, but got: " + type(xs))
  if len(xs) == 0
    throw ValueError("cannot reduce empty list")
  r = xs[0]
  for var x of slice(xs, 1)
    r = f(r, x)
  if type(xs) == "tuple"
    return tuple(r)
  elif type(xs) == "string"
    return list_join(r)
  elif type(xs) == "bytes"
    return bytes(r)
  return r
}
set_pseudomethod("list.reduce", func (xs, f): reduce(f, xs))
set_pseudomethod("tuple.reduce", func (xs, f): reduce(f, xs))
set_pseudomethod("string.reduce", func (xs, f): reduce(f, xs))
set_pseudomethod("bytes.reduce", func (xs, f): reduce(f, xs))
func sum(xs)
  return reduce(func (x, y): x + y, xs)
set_pseudomethod("list.sum", sum)
set_pseudomethod("tuple.sum", sum)
func product(xs)
  return reduce(func (x, y): x * y, xs)
set_pseudomethod("list.product", product)
set_pseudomethod("tuple.product", product)
func all(l): reduce(func (x, y): x && y, l)
set_pseudomethod("list.all", all)
set_pseudomethod("tuple.all", all)
func any(l): reduce(func (x, y): x || y, l)
set_pseudomethod("list.any", any)
set_pseudomethod("tuple.any", any)
func map(f, xs) {
  if type(f) != "function"
    throw TypeError("expected first argument to be: function, but got: " + type(f))
  if type(xs) !in ("list", "tuple", "string", "bytes")
    throw TypeError("expected second argument to be: list, tuple, string or bytes, but got: " + type(xs))
  if len(xs) == 0
    return xs
  var r = []
  for var x of xs
    list_push(r, f(x))
  if type(xs) == "tuple"
    return tuple(r)
  elif type(xs) == "string"
    return list_join(r)
  elif type(xs) == "bytes"
    return bytes(r)
  return r
}
set_pseudomethod("list.map", func (xs, f): map(f, xs))
set_pseudomethod("tuple.map", func (xs, f): map(f, xs))
set_pseudomethod("string.map", func (xs, f): map(f, xs))
set_pseudomethod("bytes.map", func (xs, f): map(f, xs))
func filter(f, xs) {
  if type(f) != "function"
    throw TypeError("expected first argument to be: function, but got: " + type(f))
  if type(xs) !in ("list", "tuple", "string", "bytes")
    throw TypeError("expected second argument to be: list, tuple, string or bytes, but got: " + type(xs))
  if len(xs) == 0
    return xs
  var r = []
  for var x of xs
    if f(x)
      list_push(r, x)
  if type(xs) == "tuple"
    return tuple(r)
  elif type(xs) == "string"
    return list_join(r)
  elif type(xs) == "bytes"
    return bytes(r)
  return r
}
set_pseudomethod("list.filter", func (xs, f): filter(f, xs))
set_pseudomethod("tuple.filter", func (xs, f): filter(f, xs))
set_pseudomethod("string.filter", func (xs, f): filter(f, xs))
set_pseudomethod("bytes.filter", func (xs, f): filter(f, xs))
func str_index(s, w) {
  if s == "" || w == ""
    return -1
  if type(s) != "string"
    throw TypeError("expected first argument to be: string, but got: " + type(s))
  if type(w) != "string"
    throw TypeError("expected second argument to be: string, but got: " + type(w))
  for var i = 0; i < len(s); i++
    if len(w) == 1 && s[i] == w
      return i
    elif slice(s, i, i+len(w)-1) == w
      return i
  return -1
}
set_pseudomethod("string.index", str_index)
func str_lstrip(s, cs=" \t\n\r\x0b\x0c") {
  if type(s) != "string"
    throw TypeError("expected first argument to be: string, but got: " + type(s))
  if type(cs) != "string"
    throw TypeError("expected second argument to be: string, but got: " + type(cs))
  if s == ""
    return s
  var i
  for i = 0; s[i] in cs && i < len(s); i++
    pass
  return slice(s, i)
}
set_pseudomethod("string.lstrip", str_lstrip)
func str_rstrip(s, cs=" \t\n\r\x0b\x0c") {
  if type(s) != "string"
    throw TypeError("expected first argument to be: string, but got: " + type(s))
  if type(cs) != "string"
    throw TypeError("expected second argument to be: string, but got: " + type(cs))
  if s == ""
    return s
  var k, i
  for k = 0, i = len(s)-1; s[i] in cs && i >= 0; k++
    i--
  return slice(s, 0, len(s)-k-1)
}
set_pseudomethod("string.rstrip", str_rstrip)
func str_strip(s, cs=" \t\n\r\x0b\x0c") {
  if type(s) != "string"
    throw TypeError("expected first argument to be: string, but got: " + type(s))
  if type(cs) != "string"
    throw TypeError("expected second argument to be: string, but got: " + type(cs))
  return str_lstrip(str_rstrip(s, cs), cs)
}
set_pseudomethod("string.strip", str_strip)
func zip() {
  if !arguments
    return []
  var l = map(len, arguments)
  l = reduce(min, l)
  var r = []
  for var i = 0; i < l; i++ {
    var t = []
    for var xs of arguments
      list_push(t, xs[i])
    list_push(r, t)
  }
  return r
}
func enumerate(l)
  if type(l) == "table"
    return zip(table_keys(l), table_values(l))
  else
    return zip(range(len(l)), l)
func str_toupper(s) {
  if type(s) != "string"
    throw TypeError("expected first argument to be: string, but got: " + type(c))
  return map(func (c): c >= 'a' && c <= 'z'? chr(ord(c) - 32): c, s)
}
set_pseudomethod("string.toupper", str_toupper)
func str_tolower(s) {
  if type(s) != "string"
    throw TypeError("expected first argument to be: string, but got: " + type(c))
  return map(func (c): c >= 'A' && c <= 'Z'? chr(ord(c) + 32): c, s)
}
set_pseudomethod("string.tolower", str_tolower)
func hex(x) {
    if type(x) != "number"
      throw TypeError("expected first argument to be: number, but got: " + type(x))
    if x == 0
      return "0x0"
    let sgn = x < 0
    if sgn 
      x = -x
    var r = ""
    for x > 0 {
        r = "0123456789abcdef"[x % 16] + r
        x //= 16
    }
    return (sgn? "-0x": "0x") + r
}
func oct(x) {
    if type(x) != "number"
      throw TypeError("expected first argument to be: number, but got: " + type(x))
    if x == 0
      return "0o0"
    let sgn = x < 0
    if sgn 
      x = -x
    var r = ""
    for x > 0 {
        r = "01234567"[x % 8] + r
        x //= 8
    }
    return (sgn? "-0o": "0o") + r
}
func format(s) {
  if type(s) != "string"
    throw TypeError("expected first argument to be: string, but got: " + type(s))
  var r = ""
  var n = 1
  for var i = 0; i < len(s); i++
    switch s[i] {
      case '_'
        if i+1 < len(s) && s[i+1] == '_' {
          r += '_'
          i++
          continue
        }
        r += repr(arguments[n++])
        break
      default
        r += s[i]
    }
  return r
}
set_pseudomethod("string.format", format)
func formatl(s, l) {
  if type(s) != "string"
    throw TypeError("expected first argument to be: string, but got: " + type(s))
  if type(l) != "list"
    throw TypeError("expected second argument to be: list, but got: " + type(l))
  return func_call(str_format, [s] + l)
}
set_pseudomethod("string.formatl", formatl)
func formatd(s, t) {
  if type(s) != "string"
    throw TypeError("expected first argument to be: string, but got: " + type(s))
  var r = ""
  var n = 1
  for var i = 0; i < len(s); i++
    switch s[i] {
      case '{'
        if i+1 < len(s) && s[i+1] == '{' {
          r += '{'
          i++
          continue
        }
        var k = ''
        i++
        for i < len(s) && s[i] != '}'
          k += s[i++]
        if i >= len(s) || s[i] != '}'
          throw ValueError("unmatched { in format specifier")
        if !k
          throw ValueError("empty format key")
        r += repr(t[k])
        break
      default
        r += s[i]
    }
  return r
}
set_pseudomethod("string.formatd", formatd)
func getch() return chr(fgetc(STDIN))
func putch(c) fputc(STDOUT, c)
func getline()
  return fgets(STDIN, 256)
func input() {
  if len(arguments) > 0
    func_call(print, arguments)
  return str_rstrip(getline(), "\n\r")
}
func open(path, mode="r"): fopen(path, mode)
set_pseudomethod("file.__enter", func () {})
set_pseudomethod("file.__leave", func (f): fclose(f))
set_pseudomethod("file.close", fclose)
set_pseudomethod("file.flush", fflush)
set_pseudomethod("file.seek", fseek)
set_pseudomethod("file.getc", fgetc)
set_pseudomethod("file.putc", fputc)
set_pseudomethod("file.gets", fgets)
set_pseudomethod("file.puts", fputs)
set_pseudomethod("file.tell", ftell)
set_pseudomethod("reference.deref", deref)
set_pseudomethod("reference.set", ref_set)
func assert(cond, msg=AssertionError())
  if !cond
    throw msg
class ListIterator { 
    constructor(this, l) {
        this.l = list(l)

        this.i = 0
        this.z = len(this.l)
    }

    __str(this): "<ListIterator>"

    __begin(this) {
        this.i = 0
        
        return this
    }

    __next(this) {
        if this.i < this.z
          return this.l[this.i++]
    }

    __end(this): this.i >= this.z
}
class OrderedTable {
    __data__ = nil

    constructor (this, v=nil) {
        this.__data__ = []

        if v !is nil {
            v = table(v)

            for var k of v
                this[k] = v[k]
        }
    }

    __type (this): "orderedtable"
    
    stringify (this, tempstack=[]) {
        if this in tempstack
            return "OrderedTable({...})"

        tempstack.push(this)

        var buf = "OrderedTable({"
        var f = true

        for var [k, v] of this.__data__ {
            if f
                f = false
            else buf += ", "

            k = k.replace(`\`, `\\`).replace(`"`, `\"`)

            if type(v) is "orderedtable"
                v = v.stringify(tempstack)
            
            buf += f`"${k}": ${v}`
        }

        buf += "})"

        return buf
    }

    __str (this) {
        return this.stringify([])
    }

    keys (this) {
        let keys = []

        for var [k, _] of this.__data__
            keys.push(k)

        return keys
    }

    values (this) {
        let values = []

        for var [_, v] of this.__data__
            values.push(v)

        return values
    }

    delete (this, k) {
        del this[k]
    }

    copy (this) {
        return OrderedTable(this.__data__)
    }

    get (this, k, d=nil) {
        k = str(k)

        for var [ok, v] of this.__data__
            if ok == k
                return v

        return d
    }

    __iter (this): ListIterator(this.keys())
    __len (this): len(this.__data__)

    __in (this, k) {
        k = str(k)

        for var [ok, _] of this.__data__
            if ok == k
                return true

        return false
    }

    __del (this, k) {
        k = str(k)

        for var [i, ok] of zip(range(len(this)), this.keys())
            if ok == k {
                del this.__data__[i]

                return
            }

        throw KeyError(k)
    }

    __index (this, k) {
        k = str(k)

        for var [ok, v] of this.__data__
            if ok == k
                return v

        throw KeyError(k)
    }

    __index_set (this, k, v) {
        k = str(k)

        for var [i, ok] of zip(range(len(this)), this.keys())
            if ok == k {
                this.__data__[i] = (ok, v)

                return
            }

        this.__data__.push((k, v))
    }
}