C++ (Cpp) SCM_CLASS_SLOT_SPEC Examples

Example #1

File: ObjCError.c Project: Hamayama/c-wrapper-mg

    Scm_Printf(port, "#<objc-error %A (%A)>"
               , SCM_OBJC_ERROR(obj)->name, SCM_OBJC_ERROR(obj)->reason);
}

static ScmObj objc_error_name_get(ScmObjCError *err)
{
    SCM_RETURN(err->name);
}

static ScmObj objc_error_reason_get(ScmObjCError *err)
{
    SCM_RETURN(err->reason);
}

static ScmClassStaticSlotSpec objc_error_slots[] = {
    SCM_CLASS_SLOT_SPEC("name", objc_error_name_get, NULL),
    SCM_CLASS_SLOT_SPEC("reason", objc_error_reason_get, NULL),
    { NULL }
};

ScmObj Scm_MakeObjCError(ScmObj name, ScmObj reason)
{
    ScmObj e = objc_error_allocate(SCM_CLASS_OBJC_ERROR, SCM_NIL);
    SCM_OBJC_ERROR(e)->name = name;
    SCM_OBJC_ERROR(e)->reason = reason;

    SCM_RETURN(e);
}

void Scm_Init_ObjCError(ScmModule *mod)
{

Example #2

File: error.c Project: Z-Shang/Gauche

        return SCM_NIL;
    }
}

static void message_args_set(ScmMessageCondition *obj, ScmObj val)
{
    ScmObj msglist = obj->message;
    if (SCM_PAIRP(msglist) && SCM_PAIRP(SCM_CDR(msglist))) {
        SCM_SET_CDR(SCM_CDR(msglist), val);
    } else {
        obj->message = Scm_Cons(msglist, Scm_Cons(msglist, val));
    }
}

static ScmClassStaticSlotSpec message_slots[] = {
    SCM_CLASS_SLOT_SPEC("message", message_get, message_set),
    SCM_CLASS_SLOT_SPEC("message-prefix",   message_prefix_get, message_prefix_set),
    SCM_CLASS_SLOT_SPEC("message-args", message_args_get, message_args_set),
    SCM_CLASS_SLOT_SPEC_END()
};

/*------------------------------------------------------------
 * Errors
 */

static ScmClass *error_cpl[] = {
    ERROR_CPL,
    NULL
};

static ScmClass *porterror_cpl[] = {

Example #3

File: mutex.c Project: qykth-git/Gauche

{
    mutex->name = name;
}

static ScmObj mutex_specific_get(ScmMutex *mutex)
{
    return mutex->specific;
}

static void mutex_specific_set(ScmMutex *mutex, ScmObj value)
{
    mutex->specific = value;
}

static ScmClassStaticSlotSpec mutex_slots[] = {
    SCM_CLASS_SLOT_SPEC("name", mutex_name_get, mutex_name_set),
    SCM_CLASS_SLOT_SPEC("state", mutex_state_get, NULL),
    SCM_CLASS_SLOT_SPEC("specific", mutex_specific_get, mutex_specific_set),
    SCM_CLASS_SLOT_SPEC_END()
};

/*
 * Make mutex
 */
ScmObj Scm_MakeMutex(ScmObj name)
{
    ScmObj m = mutex_allocate(SCM_CLASS_MUTEX, SCM_NIL);
    SCM_MUTEX(m)->name = name;
    return m;
}

Example #4

File: fcntl.c Project: Z-Shang/Gauche

  static ScmObj SCM_CPP_CAT3(flock_, name, _get)(ScmSysFlock* t)          \
  { return make(t->lock.name); }                                          \
  static void SCM_CPP_CAT3(flock_, name, _set)(ScmSysFlock* t, ScmObj v)  \
  {                                                                       \
      if (!SCM_INTEGERP(v)) Scm_Error("integer required, but got %S", v); \
      t->lock.name = (type)get(v);                                        \
  }

FLOCK_GET_N_SET(l_type, short, Scm_MakeInteger, Scm_GetInteger)
FLOCK_GET_N_SET(l_whence, short, Scm_MakeInteger, Scm_GetInteger)
FLOCK_GET_N_SET(l_start, off_t, Scm_OffsetToInteger, Scm_IntegerToOffset)
FLOCK_GET_N_SET(l_len, off_t, Scm_OffsetToInteger, Scm_IntegerToOffset)
FLOCK_GET_N_SET(l_pid, pid_t, Scm_MakeInteger, Scm_GetInteger)

static ScmClassStaticSlotSpec flock_slots[] = {
    SCM_CLASS_SLOT_SPEC("type",   flock_l_type_get, flock_l_type_set),
    SCM_CLASS_SLOT_SPEC("whence", flock_l_whence_get, flock_l_whence_set),
    SCM_CLASS_SLOT_SPEC("start",  flock_l_start_get, flock_l_start_set),
    SCM_CLASS_SLOT_SPEC("len",    flock_l_len_get, flock_l_len_set),
    SCM_CLASS_SLOT_SPEC("pid",    flock_l_pid_get, flock_l_pid_set),
    SCM_CLASS_SLOT_SPEC_END()
};

ScmObj Scm_MakeSysFlock(void)
{
    return flock_allocate(SCM_CLASS_SYS_FLOCK, SCM_NIL);
}

/*
 * Fcntl bridge
 */

Example #5

File: termios.c Project: aharisu/Gauche

}

static void termios_c_cc_set(ScmSysTermios* t, ScmObj val)
{
    if (!SCM_U8VECTORP(val)) {
        Scm_Error("cc type must be a u8vector, but got %S", val);
    }
    if (SCM_U8VECTOR_SIZE(val) != NCCS) {
        Scm_Error("size of cc must be %u, but got %u",
                  NCCS, SCM_U8VECTOR_SIZE(val));
    }
    memcpy(t->term.c_cc, SCM_U8VECTOR_ELEMENTS(val), NCCS);
}

static ScmClassStaticSlotSpec termios_slots[] = {
    SCM_CLASS_SLOT_SPEC("iflag", termios_c_iflag_get, termios_c_iflag_set),
    SCM_CLASS_SLOT_SPEC("oflag", termios_c_oflag_get, termios_c_oflag_set),
    SCM_CLASS_SLOT_SPEC("cflag", termios_c_cflag_get, termios_c_cflag_set),
    SCM_CLASS_SLOT_SPEC("lflag", termios_c_lflag_get, termios_c_lflag_set),
    SCM_CLASS_SLOT_SPEC("cc", termios_c_cc_get, termios_c_cc_set),
    SCM_CLASS_SLOT_SPEC_END()
};

ScmObj Scm_MakeSysTermios(void)
{
    return termios_allocate(NULL, SCM_NIL);
}

/*
 * pty
 */