/* mzsocket: BSD/POSIX sockets library for PLT-scheme
 * helper macros 
 * 
 * (C) Copyright 2007,2008 Dimitris Vyzovitis <vyzo at media.mit.edu>
 * 
 * mzsocket is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * mzsocket is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with mzsocket.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef _SOCKET_SCM_H
#define _SOCKET_SCM_H

#include "escheme.h"

#define REGISTER_STATIC(x) \
  scheme_register_static((void *)&x, sizeof(x))

#define SYMBOL scheme_intern_symbol
#define FIXNUM scheme_make_integer
#define FLONUM scheme_make_double
#define BOOLEAN(x) ((x)? scheme_true : scheme_false)
#define BYTES scheme_make_byte_string
#define BYTES_SIZE(x, sz) scheme_make_sized_byte_string(x, sz, 1)
#define IMMUTABLE_BYTES(x) \
  scheme_make_immutable_sized_byte_string(x, strlen(x), 1)
#define PATH scheme_make_path
#define PATH_SIZE(x, sz) scheme_make_sized_path(x, sz, 1)
#define STRING_TO_BYTES scheme_char_string_to_byte_string_locale
#define LIST scheme_build_list

#define FIXNUM_VAL SCHEME_INT_VAL
#define FLONUM_VAL SCHEME_FLOAT_VAL
#define BOOLEAN_VAL(x) (SCHEME_FALSEP(x)? 0 : 1)
#define STRING_VAL SCHEME_CHAR_STR_VAL
#define BYTES_VAL SCHEME_BYTE_STR_VAL
#define BYTES_LEN SCHEME_BYTE_STRLEN_VAL
#define PATH_VAL SCHEME_PATH_VAL
#define PATH_LEN SCHEME_PATH_LEN
#define LIST_LEN scheme_list_length

#define VECTOR(len) scheme_make_vector (len, NULL);
#define VECTOR_LEN SCHEME_VEC_SIZE
#define VECTOR_REF(x, i) (SCHEME_VEC_ELS(x)[i])
#define VECTOR_SET(x, i, v) (SCHEME_VEC_ELS(x)[i]) = v

#define FIXNUMP SCHEME_INTP
#define BYTESP SCHEME_BYTE_STRINGP
#define VECTORP SCHEME_VECTORP
#define NULLP SCHEME_NULLP
#define PATHP SCHEME_PATHP
#define CAR SCHEME_CAR
#define CDR SCHEME_CDR

#define DEFUN(name, p, mina, maxa)                   \
  scheme_add_global (name, \
    scheme_make_prim_w_arity (p, name, mina, maxa), module)
#define DEFVAR(name, val) \
  scheme_add_global (name, val, module)
#define EXPORT_VAL(name, val) \
  scheme_add_global (#name, val, module)
#define EXPORT_CONST(name) \
  scheme_add_global (#name, FIXNUM (name), module)

#define ERROR(how) \
  scheme_raise_exn( MZEXN_FAIL_CONTRACT, how )
#define ERROR2(where, how) \
  scheme_raise_exn( MZEXN_FAIL_CONTRACT, "%s: %s", where, how )

#ifndef MIN
#define MIN(x, y) (((x) < (y))? (x) : (y))
#endif

#ifdef __GNUC__
#define __EXPECT(x, v) __builtin_expect(x, v)
#else
#define __EXPECT(x, v) (x)
#endif

#define __CHECKT(x) __EXPECT(x, 0)

#define EXPECT_BOOLEAN(where, arg) \
  if (__CHECKT (!SCHEME_BOOLP (argv[arg])))                             \
    scheme_arg_mismatch (where, "expected boolean, given ", argv[arg])
#define EXPECT_FIXNUM(where, arg) \
  if (__CHECKT (!SCHEME_INTP (argv[arg])))                           \
    scheme_arg_mismatch (where, "expected fixnum, given ", argv[arg])
#define EXPECT_FLONUM(where, arg) \
  if (__CHECKT (!SCHEME_FLOATP (argv[arg])))                         \
    scheme_arg_mismatch (where, "expected flonum, given ", argv[arg])
#define EXPECT_STRING(where, arg) \
  if (__CHECKT (!SCHEME_CHAR_STRINGP (argv[arg])))                   \
    scheme_arg_mismatch (where, "expected string, given ", argv[arg])
#define EXPECT_BYTES(where, arg) \
  if (__CHECKT (!SCHEME_BYTE_STRINGP (argv[arg])))                  \
    scheme_arg_mismatch (where, "expected bytes, given ", argv[arg])
#define EXPECT_MAYBE_BYTES(where, arg) \
  if (__CHECKT (!(SCHEME_BYTE_STRINGP (argv[arg])                       \
                  || SCHEME_FALSEP (argv[arg]))))                       \
    scheme_arg_mismatch (where, "expected bytes/#f, given ", argv[arg])
#define EXPECT_MUTABLE_BYTES(where, arg) \
  if (__CHECKT (!SCHEME_MUTABLE_BYTE_STRINGP (argv[arg])))              \
    scheme_arg_mismatch (where, "expected mutable bytes, given ", argv[arg])
#define EXPECT_MAYBE_MUTABLE_BYTES(where, arg) \
  if (__CHECKT (!(SCHEME_MUTABLE_BYTE_STRINGP (argv[arg])   \
                  || SCHEME_FALSEP (argv[arg]))))                      \
    scheme_arg_mismatch (where, "expected mutable bytes/#f, given ", argv[arg])
#define EXPECT_PATH(where, arg) \
  if (__CHECKT (!SCHEME_PATHP (argv[arg])))                             \
    scheme_arg_mismatch (where, "expected path, given ", argv[arg])
#define EXPECT_PAIR(where, arg) \
  if (__CHECKT (!SCHEME_PAIRP (argv[arg])))                             \
    scheme_arg_mismatch (where, "expected pair, given ", argv[arg])
#define EXPECT_VECTOR(where, arg) \
  if (__CHECKT (!SCHEME_VECTORP (argv[arg])))                           \
    scheme_arg_mismatch (where, "expected vector, given ", argv[arg])
#define CHECK_BYTES_RANGE(where, bs, b, e) \
  if (__CHECKT (!((b >= 0) && (e > b) && (e <= BYTES_LEN(bs)))))     \
    scheme_raise_exn( MZEXN_FAIL_CONTRACT, "%s: bad range %d %d %d", \
                      where, BYTES_LEN(bs), b, e )

#endif