sclass
int sclass = classify_type(source, &s);
if (tclass & sclass & TYPE_NUM) {
if (sclass & TYPE_FOULED && unfoul(s) == t)
unrestrict(expr->right, sclass, &s);
} else if (!(sclass & TYPE_RESTRICT))
if (tclass == TYPE_PTR && is_int(sclass)) {
unrestrict(expr->right, sclass, &s);
tclass, sclass, target, source);
int sclass = classify_type(source, &s);
if (tclass & sclass & TYPE_NUM) {
if (sclass & TYPE_FOULED && unfoul(s) == t)
} else if (!(sclass & TYPE_RESTRICT))
if (!(sclass & TYPE_PTR)) {
if (t == &bool_ctype && (sclass & TYPE_PTR))
int tclass, sclass;
sclass = classify_type(stype, &stype);
if (sclass & TYPE_COMPOUND)
if (sclass & TYPE_FOULED)
if (sclass & TYPE_RESTRICT) {
if (sclass & TYPE_FOULED)
else if (sclass == TYPE_PTR) {
while (Wbitwise_pointer && tclass == TYPE_PTR && sclass == TYPE_PTR) {
sclass = classify_type(stype->ctype.base_type, &stype);
if (sclass & TYPE_RESTRICT) {
int sclass, cclass;
sclass = classify_type(switch_type, &switch_type);
if (!(sclass & cclass & TYPE_NUM))
if ((sclass | cclass) & TYPE_FLOAT)
if (!((sclass | cclass) & TYPE_RESTRICT))
cclass, sclass, case_type, switch_type)) {
unrestrict(switch_expr, sclass, &switch_type);
sclass_t sclass[] = {
int nclass = sizeof (sclass) / sizeof (sclass_t);
clp = &sclass[*cidp];
for (clp = &sclass[0]; clp < &sclass[nclass]; clp++) {
*cidp = clp - &sclass[0];
return (CL_VAPARMSIN(&sclass[parmsp->pc_cid],
return (CL_PARMSIN(&sclass[parmsp->pc_cid],
return (CL_PARMSOUT(&sclass[parmsp->pc_cid], parmsp->pc_clparms,
return (CL_VAPARMSOUT(&sclass[prmsp->pc_cid],
clname = sclass[prmsp->pc_cid].cl_name;
for (clp = sclass; clp < &sclass[nclass]; clp++)
if (clp == &sclass[nclass]) {
*cidp = clp - &sclass[0];
sc = &sclass[cid];
cl_maxglobpri = clp->cl_init(clp - sclass, PC_CLPARMSZ, &clp->cl_funcs);
t->t_clfuncs = &(sclass[cid].cl_funcs->thread);
static struct sclass fss = {
t->t_clfuncs = &(sclass[cid].cl_funcs->thread);
static struct sclass csw = {
scheduler_load(pcinfo.pc_clname, &sclass[pcinfo.pc_cid]);
error = CL_GETCLINFO(&sclass[pcinfo.pc_cid], pcinfo.pc_clinfo);
(void) strncpy(pcinfo.pc_clname, sclass[pcinfo.pc_cid].cl_name,
scheduler_load(pcinfo.pc_clname, &sclass[pcinfo.pc_cid]);
error = CL_GETCLINFO(&sclass[pcinfo.pc_cid], pcinfo.pc_clinfo);
error = CL_ADMIN(&sclass[pcadmin.pc_cid], pcadmin.pc_cladmin,
error = CL_GETCLPRI(&sclass[pcpri.pc_cid], &pcpri);
outstr = sclass[defaultcid].cl_name;
t->t_clfuncs = &(sclass[cid].cl_funcs->thread);
static struct sclass csw = {
t->t_clfuncs = &(sclass[syscid].cl_funcs->thread);
static struct sclass csw = {
t->t_clfuncs = &(sclass[cid].cl_funcs->thread);
t->t_clfuncs = &(sclass[cid].cl_funcs->thread);
static struct sclass csw = {
(void) strncpy(sp->pr_clname, sclass[t->t_cid].cl_name,
(void) strncpy(psp->pr_clname, sclass[t->t_cid].cl_name,
(void) strncpy(sp->pr_clname, sclass[t->t_cid].cl_name,
(void) strncpy(psp->pr_clname, sclass[t->t_cid].cl_name,
(void) strncpy(sp->pr_clname, sclass[t->t_cid].cl_name,
(void) strncpy(sp->pr_clname, sclass[t->t_cid].cl_name,
(void) strncpy(psp->pr_clname, sclass[t->t_cid].cl_name,
(void) strncpy(psp->pr_clname, sclass[t->t_cid].cl_name,
t->t_clfuncs = &(sclass[cid].cl_funcs->thread);
clp = &sclass[cid];
clp = &sclass[cid];
outstr = sclass[zone->zone_defaultcid].cl_name;
class_ops_t sclass;
extern struct sclass sclass[]; /* the class table */
(*(clp)->cl_funcs->sclass.cl_admin)(uaddr, reqpcredp)
(sclass[cid].cl_funcs->thread.cl_enterclass) (t, cid, \
(sclass[cid].cl_funcs->thread.cl_exitclass) ((void *)clprocp)
(*(clp)->cl_funcs->sclass.cl_getclinfo)((void *)clinfop)
(*(clp)->cl_funcs->sclass.cl_getclpri)(clprip)
(clp)->cl_funcs->sclass.cl_parmsin((void *)clparmsp)
(clp)->cl_funcs->sclass.cl_parmsout((void *)clparmsp, vaparmsp)
(clp)->cl_funcs->sclass.cl_vaparmsin((void *)clparmsp, vaparmsp)
(clp)->cl_funcs->sclass.cl_vaparmsout((void *)clparmsp, vaparmsp)
(sclass[cid].cl_funcs->sclass.cl_alloc) (pp, flag)
#define CL_FREE(cid, bufp) (sclass[cid].cl_funcs->sclass.cl_free) (bufp)
struct sclass *sched_class;