hexsha
stringlengths 40
40
| repo
stringlengths 5
105
| path
stringlengths 3
173
| license
sequence | language
stringclasses 1
value | identifier
stringlengths 1
438
| return_type
stringlengths 1
106
⌀ | original_string
stringlengths 21
40.7k
| original_docstring
stringlengths 18
13.4k
| docstring
stringlengths 11
3.24k
| docstring_tokens
sequence | code
stringlengths 14
20.4k
| code_tokens
sequence | short_docstring
stringlengths 0
4.36k
| short_docstring_tokens
sequence | comment
sequence | parameters
list | docstring_params
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
a71fe7510ac42dd2321ea323e7dc738cb77e91a9 | atrens/DragonFlyBSD-src | sys/netgraph/ng_device.c | [
"BSD-3-Clause"
] | C | ng_device_disconnect | int | static int
ng_device_disconnect(hook_p hook)
{
struct ngd_softc *sc = &ngd_softc;
struct ngd_connection * connection = NULL;
struct ngd_connection * tmp;
#ifdef NGD_DEBUG
kprintf("%s()\n", __func__);
#endif /* NGD_DEBUG */
SLIST_FOREACH(tmp, &sc->head, links) {
if(tmp->active_hook == hook) {
connection = tmp;
}
}
if(connection == NULL) {
kprintf("%s(): connection still NULL, no hook found\n",
__func__);
return(-1);
}
kfree(connection->readq, M_DEVBUF);
destroy_dev(connection->ngddev);
SLIST_REMOVE(&sc->head, connection, ngd_connection, links);
return(0);
} | /*
* Removal of the last link destroys the node
*/ | Removal of the last link destroys the node | [
"Removal",
"of",
"the",
"last",
"link",
"destroys",
"the",
"node"
] | static int
ng_device_disconnect(hook_p hook)
{
struct ngd_softc *sc = &ngd_softc;
struct ngd_connection * connection = NULL;
struct ngd_connection * tmp;
#ifdef NGD_DEBUG
kprintf("%s()\n", __func__);
#endif
SLIST_FOREACH(tmp, &sc->head, links) {
if(tmp->active_hook == hook) {
connection = tmp;
}
}
if(connection == NULL) {
kprintf("%s(): connection still NULL, no hook found\n",
__func__);
return(-1);
}
kfree(connection->readq, M_DEVBUF);
destroy_dev(connection->ngddev);
SLIST_REMOVE(&sc->head, connection, ngd_connection, links);
return(0);
} | [
"static",
"int",
"ng_device_disconnect",
"(",
"hook_p",
"hook",
")",
"{",
"struct",
"ngd_softc",
"*",
"sc",
"=",
"&",
"ngd_softc",
";",
"struct",
"ngd_connection",
"*",
"connection",
"=",
"NULL",
";",
"struct",
"ngd_connection",
"*",
"tmp",
";",
"#ifdef",
"NGD_DEBUG",
"kprintf",
"(",
"\"",
"\\n",
"\"",
",",
"__func__",
")",
";",
"#endif",
"SLIST_FOREACH",
"(",
"tmp",
",",
"&",
"sc",
"->",
"head",
",",
"links",
")",
"",
"{",
"if",
"(",
"tmp",
"->",
"active_hook",
"==",
"hook",
")",
"{",
"connection",
"=",
"tmp",
";",
"}",
"}",
"if",
"(",
"connection",
"==",
"NULL",
")",
"{",
"kprintf",
"(",
"\"",
"\\n",
"\"",
",",
"__func__",
")",
";",
"return",
"(",
"-1",
")",
";",
"}",
"kfree",
"(",
"connection",
"->",
"readq",
",",
"M_DEVBUF",
")",
";",
"destroy_dev",
"(",
"connection",
"->",
"ngddev",
")",
";",
"SLIST_REMOVE",
"(",
"&",
"sc",
"->",
"head",
",",
"connection",
",",
"ngd_connection",
",",
"links",
")",
";",
"return",
"(",
"0",
")",
";",
"}"
] | Removal of the last link destroys the node | [
"Removal",
"of",
"the",
"last",
"link",
"destroys",
"the",
"node"
] | [
"/* NGD_DEBUG */"
] | [
{
"param": "hook",
"type": "hook_p"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "hook",
"type": "hook_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
a71fe7510ac42dd2321ea323e7dc738cb77e91a9 | atrens/DragonFlyBSD-src | sys/netgraph/ng_device.c | [
"BSD-3-Clause"
] | C | ngdioctl | int | static int
ngdioctl(cdev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td)
{
struct ngd_softc *sc = &ngd_softc;
struct ngd_connection * connection = NULL;
struct ngd_connection * tmp;
int error = 0;
struct ng_mesg *msg;
struct ngd_param_s * datap;
#ifdef NGD_DEBUG
kprintf("%s()\n", __func__);
#endif /* NGD_DEBUG */
SLIST_FOREACH(tmp, &sc->head, links) {
if(tmp->ngddev == dev) {
connection = tmp;
}
}
if(connection == NULL) {
kprintf("%s(): connection still NULL, no dev found\n",
__func__);
return(-1);
}
/* NG_MKMESSAGE(msg, cookie, cmdid, len, how) */
NG_MKMESSAGE(msg, NGM_DEVICE_COOKIE, cmd, sizeof(struct ngd_param_s),
M_NOWAIT);
if (msg == NULL) {
kprintf("%s(): msg == NULL\n", __func__);
goto nomsg;
}
/* pass the ioctl data into the ->data area */
datap = (struct ngd_param_s *)msg->data;
datap->p = addr;
/*ng_send_msg(node_p here, struct ng_mesg *msg,
const char *address, struct ng_mesg **resp); */
error = ng_send_msg(sc->node, msg,
NG_HOOK_NAME(connection->active_hook), NULL);
if(error)
kprintf("%s(): ng_send_msg() error: %d\n", __func__, error);
nomsg:
return(0);
} | /*
* process ioctl
*
* they are translated into netgraph messages and passed on
*
*/ | process ioctl
they are translated into netgraph messages and passed on | [
"process",
"ioctl",
"they",
"are",
"translated",
"into",
"netgraph",
"messages",
"and",
"passed",
"on"
] | static int
ngdioctl(cdev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td)
{
struct ngd_softc *sc = &ngd_softc;
struct ngd_connection * connection = NULL;
struct ngd_connection * tmp;
int error = 0;
struct ng_mesg *msg;
struct ngd_param_s * datap;
#ifdef NGD_DEBUG
kprintf("%s()\n", __func__);
#endif
SLIST_FOREACH(tmp, &sc->head, links) {
if(tmp->ngddev == dev) {
connection = tmp;
}
}
if(connection == NULL) {
kprintf("%s(): connection still NULL, no dev found\n",
__func__);
return(-1);
}
NG_MKMESSAGE(msg, NGM_DEVICE_COOKIE, cmd, sizeof(struct ngd_param_s),
M_NOWAIT);
if (msg == NULL) {
kprintf("%s(): msg == NULL\n", __func__);
goto nomsg;
}
datap = (struct ngd_param_s *)msg->data;
datap->p = addr;
error = ng_send_msg(sc->node, msg,
NG_HOOK_NAME(connection->active_hook), NULL);
if(error)
kprintf("%s(): ng_send_msg() error: %d\n", __func__, error);
nomsg:
return(0);
} | [
"static",
"int",
"ngdioctl",
"(",
"cdev_t",
"dev",
",",
"u_long",
"cmd",
",",
"caddr_t",
"addr",
",",
"int",
"flag",
",",
"struct",
"thread",
"*",
"td",
")",
"{",
"struct",
"ngd_softc",
"*",
"sc",
"=",
"&",
"ngd_softc",
";",
"struct",
"ngd_connection",
"*",
"connection",
"=",
"NULL",
";",
"struct",
"ngd_connection",
"*",
"tmp",
";",
"int",
"error",
"=",
"0",
";",
"struct",
"ng_mesg",
"*",
"msg",
";",
"struct",
"ngd_param_s",
"*",
"datap",
";",
"#ifdef",
"NGD_DEBUG",
"kprintf",
"(",
"\"",
"\\n",
"\"",
",",
"__func__",
")",
";",
"#endif",
"SLIST_FOREACH",
"(",
"tmp",
",",
"&",
"sc",
"->",
"head",
",",
"links",
")",
"",
"{",
"if",
"(",
"tmp",
"->",
"ngddev",
"==",
"dev",
")",
"{",
"connection",
"=",
"tmp",
";",
"}",
"}",
"if",
"(",
"connection",
"==",
"NULL",
")",
"{",
"kprintf",
"(",
"\"",
"\\n",
"\"",
",",
"__func__",
")",
";",
"return",
"(",
"-1",
")",
";",
"}",
"NG_MKMESSAGE",
"(",
"msg",
",",
"NGM_DEVICE_COOKIE",
",",
"cmd",
",",
"sizeof",
"(",
"struct",
"ngd_param_s",
")",
",",
"M_NOWAIT",
")",
";",
"if",
"(",
"msg",
"==",
"NULL",
")",
"{",
"kprintf",
"(",
"\"",
"\\n",
"\"",
",",
"__func__",
")",
";",
"goto",
"nomsg",
";",
"}",
"datap",
"=",
"(",
"struct",
"ngd_param_s",
"*",
")",
"msg",
"->",
"data",
";",
"datap",
"->",
"p",
"=",
"addr",
";",
"error",
"=",
"ng_send_msg",
"(",
"sc",
"->",
"node",
",",
"msg",
",",
"NG_HOOK_NAME",
"(",
"connection",
"->",
"active_hook",
")",
",",
"NULL",
")",
";",
"if",
"(",
"error",
")",
"kprintf",
"(",
"\"",
"\\n",
"\"",
",",
"__func__",
",",
"error",
")",
";",
"nomsg",
":",
"return",
"(",
"0",
")",
";",
"}"
] | process ioctl
they are translated into netgraph messages and passed on | [
"process",
"ioctl",
"they",
"are",
"translated",
"into",
"netgraph",
"messages",
"and",
"passed",
"on"
] | [
"/* NGD_DEBUG */",
"/* NG_MKMESSAGE(msg, cookie, cmdid, len, how) */",
"/* pass the ioctl data into the ->data area */",
"/*ng_send_msg(node_p here, struct ng_mesg *msg,\n\t\t const char *address, struct ng_mesg **resp); */"
] | [
{
"param": "dev",
"type": "cdev_t"
},
{
"param": "cmd",
"type": "u_long"
},
{
"param": "addr",
"type": "caddr_t"
},
{
"param": "flag",
"type": "int"
},
{
"param": "td",
"type": "struct thread"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "dev",
"type": "cdev_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "cmd",
"type": "u_long",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "addr",
"type": "caddr_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "flag",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "td",
"type": "struct thread",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
a71fe7510ac42dd2321ea323e7dc738cb77e91a9 | atrens/DragonFlyBSD-src | sys/netgraph/ng_device.c | [
"BSD-3-Clause"
] | C | ngdread | int | static int
ngdread(cdev_t dev, struct uio *uio, int flag)
{
int ret = 0, amnt;
char buffer[uio->uio_resid+1];
struct ngd_softc *sc = &ngd_softc;
struct ngd_connection * connection = NULL;
struct ngd_connection * tmp;
#ifdef NGD_DEBUG
kprintf("%s()\n", __func__);
#endif /* NGD_DEBUG */
SLIST_FOREACH(tmp, &sc->head, links) {
if(tmp->ngddev == dev) {
connection = tmp;
}
}
if(connection == NULL) {
kprintf("%s(): connection still NULL, no dev found\n", __func__);
return(-1);
}
while ( ( uio->uio_resid > 0 ) && ( connection->loc > 0 ) ) {
amnt = MIN(uio->uio_resid, connection->loc);
memcpy(buffer, connection->readq, amnt);
memcpy(connection->readq, connection->readq+amnt,
connection->loc-amnt);
connection->loc -= amnt;
ret = uiomove((caddr_t)buffer, amnt, uio);
if(ret != 0)
goto error;
}
return(0);
error:
kprintf("%s(): uiomove returns error %d\n", __func__, ret);
/* do error cleanup here */
return(ret);
} | /*
* This function is called when a read(2) is done to our device.
* We pass the data available in kernelspace on into userland using
* uiomove.
*/ | This function is called when a read(2) is done to our device.
We pass the data available in kernelspace on into userland using
uiomove. | [
"This",
"function",
"is",
"called",
"when",
"a",
"read",
"(",
"2",
")",
"is",
"done",
"to",
"our",
"device",
".",
"We",
"pass",
"the",
"data",
"available",
"in",
"kernelspace",
"on",
"into",
"userland",
"using",
"uiomove",
"."
] | static int
ngdread(cdev_t dev, struct uio *uio, int flag)
{
int ret = 0, amnt;
char buffer[uio->uio_resid+1];
struct ngd_softc *sc = &ngd_softc;
struct ngd_connection * connection = NULL;
struct ngd_connection * tmp;
#ifdef NGD_DEBUG
kprintf("%s()\n", __func__);
#endif
SLIST_FOREACH(tmp, &sc->head, links) {
if(tmp->ngddev == dev) {
connection = tmp;
}
}
if(connection == NULL) {
kprintf("%s(): connection still NULL, no dev found\n", __func__);
return(-1);
}
while ( ( uio->uio_resid > 0 ) && ( connection->loc > 0 ) ) {
amnt = MIN(uio->uio_resid, connection->loc);
memcpy(buffer, connection->readq, amnt);
memcpy(connection->readq, connection->readq+amnt,
connection->loc-amnt);
connection->loc -= amnt;
ret = uiomove((caddr_t)buffer, amnt, uio);
if(ret != 0)
goto error;
}
return(0);
error:
kprintf("%s(): uiomove returns error %d\n", __func__, ret);
return(ret);
} | [
"static",
"int",
"ngdread",
"(",
"cdev_t",
"dev",
",",
"struct",
"uio",
"*",
"uio",
",",
"int",
"flag",
")",
"{",
"int",
"ret",
"=",
"0",
",",
"amnt",
";",
"char",
"buffer",
"[",
"uio",
"->",
"uio_resid",
"+",
"1",
"]",
";",
"struct",
"ngd_softc",
"*",
"sc",
"=",
"&",
"ngd_softc",
";",
"struct",
"ngd_connection",
"*",
"connection",
"=",
"NULL",
";",
"struct",
"ngd_connection",
"*",
"tmp",
";",
"#ifdef",
"NGD_DEBUG",
"kprintf",
"(",
"\"",
"\\n",
"\"",
",",
"__func__",
")",
";",
"#endif",
"SLIST_FOREACH",
"(",
"tmp",
",",
"&",
"sc",
"->",
"head",
",",
"links",
")",
"",
"{",
"if",
"(",
"tmp",
"->",
"ngddev",
"==",
"dev",
")",
"{",
"connection",
"=",
"tmp",
";",
"}",
"}",
"if",
"(",
"connection",
"==",
"NULL",
")",
"{",
"kprintf",
"(",
"\"",
"\\n",
"\"",
",",
"__func__",
")",
";",
"return",
"(",
"-1",
")",
";",
"}",
"while",
"(",
"(",
"uio",
"->",
"uio_resid",
">",
"0",
")",
"&&",
"(",
"connection",
"->",
"loc",
">",
"0",
")",
")",
"{",
"amnt",
"=",
"MIN",
"(",
"uio",
"->",
"uio_resid",
",",
"connection",
"->",
"loc",
")",
";",
"memcpy",
"(",
"buffer",
",",
"connection",
"->",
"readq",
",",
"amnt",
")",
";",
"memcpy",
"(",
"connection",
"->",
"readq",
",",
"connection",
"->",
"readq",
"+",
"amnt",
",",
"connection",
"->",
"loc",
"-",
"amnt",
")",
";",
"connection",
"->",
"loc",
"-=",
"amnt",
";",
"ret",
"=",
"uiomove",
"(",
"(",
"caddr_t",
")",
"buffer",
",",
"amnt",
",",
"uio",
")",
";",
"if",
"(",
"ret",
"!=",
"0",
")",
"goto",
"error",
";",
"}",
"return",
"(",
"0",
")",
";",
"error",
":",
"kprintf",
"(",
"\"",
"\\n",
"\"",
",",
"__func__",
",",
"ret",
")",
";",
"return",
"(",
"ret",
")",
";",
"}"
] | This function is called when a read(2) is done to our device. | [
"This",
"function",
"is",
"called",
"when",
"a",
"read",
"(",
"2",
")",
"is",
"done",
"to",
"our",
"device",
"."
] | [
"/* NGD_DEBUG */",
"/* do error cleanup here */"
] | [
{
"param": "dev",
"type": "cdev_t"
},
{
"param": "uio",
"type": "struct uio"
},
{
"param": "flag",
"type": "int"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "dev",
"type": "cdev_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "uio",
"type": "struct uio",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "flag",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
a71fe7510ac42dd2321ea323e7dc738cb77e91a9 | atrens/DragonFlyBSD-src | sys/netgraph/ng_device.c | [
"BSD-3-Clause"
] | C | ngdwrite | int | static int
ngdwrite(cdev_t dev, struct uio *uio, int flag)
{
int ret;
int error = 0;
struct mbuf *m;
char buffer[uio->uio_resid];
int len = uio->uio_resid;
struct ngd_softc *sc =& ngd_softc;
struct ngd_connection * connection = NULL;
struct ngd_connection * tmp;
#ifdef NGD_DEBUG
kprintf("%s()\n", __func__);
#endif /* NGD_DEBUG */
SLIST_FOREACH(tmp, &sc->head, links) {
if(tmp->ngddev == dev) {
connection = tmp;
}
}
if(connection == NULL) {
kprintf("%s(): connection still NULL, no dev found\n", __func__);
return(-1);
}
if (len > 0) {
if ((ret = uiomove((caddr_t)buffer, len, uio)) != 0)
goto error;
} else
kprintf("%s(): len <= 0 : supposed to happen?!\n", __func__);
m = m_devget(buffer, len, 0, NULL);
NG_SEND_DATA_ONLY(error, connection->active_hook, m);
return(0);
error:
/* do error cleanup here */
kprintf("%s(): uiomove returned err: %d\n", __func__, ret);
return(ret);
} | /*
* This function is called when our device is written to.
* We read the data from userland into our local buffer and pass it on
* into the remote hook.
*
*/ | This function is called when our device is written to.
We read the data from userland into our local buffer and pass it on
into the remote hook. | [
"This",
"function",
"is",
"called",
"when",
"our",
"device",
"is",
"written",
"to",
".",
"We",
"read",
"the",
"data",
"from",
"userland",
"into",
"our",
"local",
"buffer",
"and",
"pass",
"it",
"on",
"into",
"the",
"remote",
"hook",
"."
] | static int
ngdwrite(cdev_t dev, struct uio *uio, int flag)
{
int ret;
int error = 0;
struct mbuf *m;
char buffer[uio->uio_resid];
int len = uio->uio_resid;
struct ngd_softc *sc =& ngd_softc;
struct ngd_connection * connection = NULL;
struct ngd_connection * tmp;
#ifdef NGD_DEBUG
kprintf("%s()\n", __func__);
#endif
SLIST_FOREACH(tmp, &sc->head, links) {
if(tmp->ngddev == dev) {
connection = tmp;
}
}
if(connection == NULL) {
kprintf("%s(): connection still NULL, no dev found\n", __func__);
return(-1);
}
if (len > 0) {
if ((ret = uiomove((caddr_t)buffer, len, uio)) != 0)
goto error;
} else
kprintf("%s(): len <= 0 : supposed to happen?!\n", __func__);
m = m_devget(buffer, len, 0, NULL);
NG_SEND_DATA_ONLY(error, connection->active_hook, m);
return(0);
error:
kprintf("%s(): uiomove returned err: %d\n", __func__, ret);
return(ret);
} | [
"static",
"int",
"ngdwrite",
"(",
"cdev_t",
"dev",
",",
"struct",
"uio",
"*",
"uio",
",",
"int",
"flag",
")",
"{",
"int",
"ret",
";",
"int",
"error",
"=",
"0",
";",
"struct",
"mbuf",
"*",
"m",
";",
"char",
"buffer",
"[",
"uio",
"->",
"uio_resid",
"]",
";",
"int",
"len",
"=",
"uio",
"->",
"uio_resid",
";",
"struct",
"ngd_softc",
"*",
"sc",
"=",
"&",
"ngd_softc",
";",
"struct",
"ngd_connection",
"*",
"connection",
"=",
"NULL",
";",
"struct",
"ngd_connection",
"*",
"tmp",
";",
"#ifdef",
"NGD_DEBUG",
"kprintf",
"(",
"\"",
"\\n",
"\"",
",",
"__func__",
")",
";",
"#endif",
"SLIST_FOREACH",
"(",
"tmp",
",",
"&",
"sc",
"->",
"head",
",",
"links",
")",
"",
"{",
"if",
"(",
"tmp",
"->",
"ngddev",
"==",
"dev",
")",
"{",
"connection",
"=",
"tmp",
";",
"}",
"}",
"if",
"(",
"connection",
"==",
"NULL",
")",
"{",
"kprintf",
"(",
"\"",
"\\n",
"\"",
",",
"__func__",
")",
";",
"return",
"(",
"-1",
")",
";",
"}",
"if",
"(",
"len",
">",
"0",
")",
"{",
"if",
"(",
"(",
"ret",
"=",
"uiomove",
"(",
"(",
"caddr_t",
")",
"buffer",
",",
"len",
",",
"uio",
")",
")",
"!=",
"0",
")",
"goto",
"error",
";",
"}",
"else",
"kprintf",
"(",
"\"",
"\\n",
"\"",
",",
"__func__",
")",
";",
"m",
"=",
"m_devget",
"(",
"buffer",
",",
"len",
",",
"0",
",",
"NULL",
")",
";",
"NG_SEND_DATA_ONLY",
"(",
"error",
",",
"connection",
"->",
"active_hook",
",",
"m",
")",
";",
"return",
"(",
"0",
")",
";",
"error",
":",
"kprintf",
"(",
"\"",
"\\n",
"\"",
",",
"__func__",
",",
"ret",
")",
";",
"return",
"(",
"ret",
")",
";",
"}"
] | This function is called when our device is written to. | [
"This",
"function",
"is",
"called",
"when",
"our",
"device",
"is",
"written",
"to",
"."
] | [
"/* NGD_DEBUG */",
"/* do error cleanup here */"
] | [
{
"param": "dev",
"type": "cdev_t"
},
{
"param": "uio",
"type": "struct uio"
},
{
"param": "flag",
"type": "int"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "dev",
"type": "cdev_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "uio",
"type": "struct uio",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "flag",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
a71fe7510ac42dd2321ea323e7dc738cb77e91a9 | atrens/DragonFlyBSD-src | sys/netgraph/ng_device.c | [
"BSD-3-Clause"
] | C | ngdpoll | int | static int
ngdpoll(cdev_t dev, int events, struct thread *td)
{
int revents = 0;
struct ngd_softc *sc = &ngd_softc;
struct ngd_connection * connection = NULL;
struct ngd_connection * tmp;
if (events & (POLLIN | POLLRDNORM)) {
/* get the connection we have to know the loc from */
SLIST_FOREACH(tmp, &sc->head, links) {
if(tmp->ngddev == dev) {
connection = tmp;
}
}
if(connection == NULL) {
kprintf("%s(): ERROR: connection still NULL, "
"no dev found\n", __func__);
return(-1);
}
if (connection->loc > 0)
revents |= events & (POLLIN | POLLRDNORM);
}
return(revents);
} | /*
* we are being polled/selected
* check if there is data available for read
*/ | we are being polled/selected
check if there is data available for read | [
"we",
"are",
"being",
"polled",
"/",
"selected",
"check",
"if",
"there",
"is",
"data",
"available",
"for",
"read"
] | static int
ngdpoll(cdev_t dev, int events, struct thread *td)
{
int revents = 0;
struct ngd_softc *sc = &ngd_softc;
struct ngd_connection * connection = NULL;
struct ngd_connection * tmp;
if (events & (POLLIN | POLLRDNORM)) {
SLIST_FOREACH(tmp, &sc->head, links) {
if(tmp->ngddev == dev) {
connection = tmp;
}
}
if(connection == NULL) {
kprintf("%s(): ERROR: connection still NULL, "
"no dev found\n", __func__);
return(-1);
}
if (connection->loc > 0)
revents |= events & (POLLIN | POLLRDNORM);
}
return(revents);
} | [
"static",
"int",
"ngdpoll",
"(",
"cdev_t",
"dev",
",",
"int",
"events",
",",
"struct",
"thread",
"*",
"td",
")",
"{",
"int",
"revents",
"=",
"0",
";",
"struct",
"ngd_softc",
"*",
"sc",
"=",
"&",
"ngd_softc",
";",
"struct",
"ngd_connection",
"*",
"connection",
"=",
"NULL",
";",
"struct",
"ngd_connection",
"*",
"tmp",
";",
"if",
"(",
"events",
"&",
"(",
"POLLIN",
"|",
"POLLRDNORM",
")",
")",
"{",
"SLIST_FOREACH",
"(",
"tmp",
",",
"&",
"sc",
"->",
"head",
",",
"links",
")",
"",
"{",
"if",
"(",
"tmp",
"->",
"ngddev",
"==",
"dev",
")",
"{",
"connection",
"=",
"tmp",
";",
"}",
"}",
"if",
"(",
"connection",
"==",
"NULL",
")",
"{",
"kprintf",
"(",
"\"",
"\"",
"\"",
"\\n",
"\"",
",",
"__func__",
")",
";",
"return",
"(",
"-1",
")",
";",
"}",
"if",
"(",
"connection",
"->",
"loc",
">",
"0",
")",
"revents",
"|=",
"events",
"&",
"(",
"POLLIN",
"|",
"POLLRDNORM",
")",
";",
"}",
"return",
"(",
"revents",
")",
";",
"}"
] | we are being polled/selected
check if there is data available for read | [
"we",
"are",
"being",
"polled",
"/",
"selected",
"check",
"if",
"there",
"is",
"data",
"available",
"for",
"read"
] | [
"/* get the connection we have to know the loc from */"
] | [
{
"param": "dev",
"type": "cdev_t"
},
{
"param": "events",
"type": "int"
},
{
"param": "td",
"type": "struct thread"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "dev",
"type": "cdev_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "events",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "td",
"type": "struct thread",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
af236acac1d83a7bb2da61f7563093e9d31d6045 | atrens/DragonFlyBSD-src | contrib/tnftp/src/ftp.c | [
"BSD-3-Clause"
] | C | ai_unmapped | void | void
ai_unmapped(struct addrinfo *ai)
{
#ifdef INET6
struct sockaddr_in6 *sin6;
struct sockaddr_in sin;
socklen_t len;
if (ai->ai_family != AF_INET6)
return;
if (ai->ai_addrlen != sizeof(struct sockaddr_in6) ||
sizeof(sin) > ai->ai_addrlen)
return;
sin6 = (struct sockaddr_in6 *)ai->ai_addr;
if (!IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr))
return;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
len = sizeof(struct sockaddr_in);
memcpy(&sin.sin_addr, &sin6->sin6_addr.s6_addr[12],
sizeof(sin.sin_addr));
sin.sin_port = sin6->sin6_port;
ai->ai_family = AF_INET;
#if defined(HAVE_STRUCT_SOCKADDR_IN_SIN_LEN)
sin.sin_len = len;
#endif
memcpy(ai->ai_addr, &sin, len);
ai->ai_addrlen = len;
#endif
} | /*
* Ensure that ai->ai_addr is NOT an IPv4 mapped address.
* IPv4 mapped address complicates too many things in FTP
* protocol handling, as FTP protocol is defined differently
* between IPv4 and IPv6.
*
* This may not be the best way to handle this situation,
* since the semantics of IPv4 mapped address is defined in
* the kernel. There are configurations where we should use
* IPv4 mapped address as native IPv6 address, not as
* "an IPv6 address that embeds IPv4 address" (namely, SIIT).
*
* More complete solution would be to have an additional
* getsockopt to grab "real" peername/sockname. "real"
* peername/sockname will be AF_INET if IPv4 mapped address
* is used to embed IPv4 address, and will be AF_INET6 if
* we use it as native. What a mess!
*/ | Ensure that ai->ai_addr is NOT an IPv4 mapped address.
IPv4 mapped address complicates too many things in FTP
protocol handling, as FTP protocol is defined differently
between IPv4 and IPv6.
This may not be the best way to handle this situation,
since the semantics of IPv4 mapped address is defined in
the kernel. There are configurations where we should use
IPv4 mapped address as native IPv6 address, not as
"an IPv6 address that embeds IPv4 address" (namely, SIIT).
More complete solution would be to have an additional
getsockopt to grab "real" peername/sockname. "real"
peername/sockname will be AF_INET if IPv4 mapped address
is used to embed IPv4 address, and will be AF_INET6 if
we use it as native. What a mess! | [
"Ensure",
"that",
"ai",
"-",
">",
"ai_addr",
"is",
"NOT",
"an",
"IPv4",
"mapped",
"address",
".",
"IPv4",
"mapped",
"address",
"complicates",
"too",
"many",
"things",
"in",
"FTP",
"protocol",
"handling",
"as",
"FTP",
"protocol",
"is",
"defined",
"differently",
"between",
"IPv4",
"and",
"IPv6",
".",
"This",
"may",
"not",
"be",
"the",
"best",
"way",
"to",
"handle",
"this",
"situation",
"since",
"the",
"semantics",
"of",
"IPv4",
"mapped",
"address",
"is",
"defined",
"in",
"the",
"kernel",
".",
"There",
"are",
"configurations",
"where",
"we",
"should",
"use",
"IPv4",
"mapped",
"address",
"as",
"native",
"IPv6",
"address",
"not",
"as",
"\"",
"an",
"IPv6",
"address",
"that",
"embeds",
"IPv4",
"address",
"\"",
"(",
"namely",
"SIIT",
")",
".",
"More",
"complete",
"solution",
"would",
"be",
"to",
"have",
"an",
"additional",
"getsockopt",
"to",
"grab",
"\"",
"real",
"\"",
"peername",
"/",
"sockname",
".",
"\"",
"real",
"\"",
"peername",
"/",
"sockname",
"will",
"be",
"AF_INET",
"if",
"IPv4",
"mapped",
"address",
"is",
"used",
"to",
"embed",
"IPv4",
"address",
"and",
"will",
"be",
"AF_INET6",
"if",
"we",
"use",
"it",
"as",
"native",
".",
"What",
"a",
"mess!"
] | void
ai_unmapped(struct addrinfo *ai)
{
#ifdef INET6
struct sockaddr_in6 *sin6;
struct sockaddr_in sin;
socklen_t len;
if (ai->ai_family != AF_INET6)
return;
if (ai->ai_addrlen != sizeof(struct sockaddr_in6) ||
sizeof(sin) > ai->ai_addrlen)
return;
sin6 = (struct sockaddr_in6 *)ai->ai_addr;
if (!IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr))
return;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
len = sizeof(struct sockaddr_in);
memcpy(&sin.sin_addr, &sin6->sin6_addr.s6_addr[12],
sizeof(sin.sin_addr));
sin.sin_port = sin6->sin6_port;
ai->ai_family = AF_INET;
#if defined(HAVE_STRUCT_SOCKADDR_IN_SIN_LEN)
sin.sin_len = len;
#endif
memcpy(ai->ai_addr, &sin, len);
ai->ai_addrlen = len;
#endif
} | [
"void",
"ai_unmapped",
"(",
"struct",
"addrinfo",
"*",
"ai",
")",
"{",
"#ifdef",
"INET6",
"struct",
"sockaddr_in6",
"*",
"sin6",
";",
"struct",
"sockaddr_in",
"sin",
";",
"socklen_t",
"len",
";",
"if",
"(",
"ai",
"->",
"ai_family",
"!=",
"AF_INET6",
")",
"return",
";",
"if",
"(",
"ai",
"->",
"ai_addrlen",
"!=",
"sizeof",
"(",
"struct",
"sockaddr_in6",
")",
"||",
"sizeof",
"(",
"sin",
")",
">",
"ai",
"->",
"ai_addrlen",
")",
"return",
";",
"sin6",
"=",
"(",
"struct",
"sockaddr_in6",
"*",
")",
"ai",
"->",
"ai_addr",
";",
"if",
"(",
"!",
"IN6_IS_ADDR_V4MAPPED",
"(",
"&",
"sin6",
"->",
"sin6_addr",
")",
")",
"return",
";",
"memset",
"(",
"&",
"sin",
",",
"0",
",",
"sizeof",
"(",
"sin",
")",
")",
";",
"sin",
".",
"sin_family",
"=",
"AF_INET",
";",
"len",
"=",
"sizeof",
"(",
"struct",
"sockaddr_in",
")",
";",
"memcpy",
"(",
"&",
"sin",
".",
"sin_addr",
",",
"&",
"sin6",
"->",
"sin6_addr",
".",
"s6_addr",
"[",
"12",
"]",
",",
"sizeof",
"(",
"sin",
".",
"sin_addr",
")",
")",
";",
"sin",
".",
"sin_port",
"=",
"sin6",
"->",
"sin6_port",
";",
"ai",
"->",
"ai_family",
"=",
"AF_INET",
";",
"#if",
"defined",
"(",
"HAVE_STRUCT_SOCKADDR_IN_SIN_LEN",
")",
"\n",
"sin",
".",
"sin_len",
"=",
"len",
";",
"#endif",
"memcpy",
"(",
"ai",
"->",
"ai_addr",
",",
"&",
"sin",
",",
"len",
")",
";",
"ai",
"->",
"ai_addrlen",
"=",
"len",
";",
"#endif",
"}"
] | Ensure that ai->ai_addr is NOT an IPv4 mapped address. | [
"Ensure",
"that",
"ai",
"-",
">",
"ai_addr",
"is",
"NOT",
"an",
"IPv4",
"mapped",
"address",
"."
] | [] | [
{
"param": "ai",
"type": "struct addrinfo"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "ai",
"type": "struct addrinfo",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
cb0f2be314e8f87be62bdca9a18ef8bb8da4eaa1 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/c-family/c-semantics.c | [
"BSD-3-Clause"
] | C | push_stmt_list | tree | tree
push_stmt_list (void)
{
tree t;
t = alloc_stmt_list ();
VEC_safe_push (tree, gc, stmt_list_stack, t);
return t;
} | /* Create an empty statement tree rooted at T. */ | Create an empty statement tree rooted at T. | [
"Create",
"an",
"empty",
"statement",
"tree",
"rooted",
"at",
"T",
"."
] | tree
push_stmt_list (void)
{
tree t;
t = alloc_stmt_list ();
VEC_safe_push (tree, gc, stmt_list_stack, t);
return t;
} | [
"tree",
"push_stmt_list",
"(",
"void",
")",
"{",
"tree",
"t",
";",
"t",
"=",
"alloc_stmt_list",
"(",
")",
";",
"VEC_safe_push",
"(",
"tree",
",",
"gc",
",",
"stmt_list_stack",
",",
"t",
")",
";",
"return",
"t",
";",
"}"
] | Create an empty statement tree rooted at T. | [
"Create",
"an",
"empty",
"statement",
"tree",
"rooted",
"at",
"T",
"."
] | [] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
cb0f2be314e8f87be62bdca9a18ef8bb8da4eaa1 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/c-family/c-semantics.c | [
"BSD-3-Clause"
] | C | pop_stmt_list | tree | tree
pop_stmt_list (tree t)
{
tree u = NULL_TREE;
/* Pop statement lists until we reach the target level. The extra
nestings will be due to outstanding cleanups. */
while (1)
{
u = VEC_pop (tree, stmt_list_stack);
if (!VEC_empty (tree, stmt_list_stack))
{
tree x = VEC_last (tree, stmt_list_stack);
STATEMENT_LIST_HAS_LABEL (x) |= STATEMENT_LIST_HAS_LABEL (u);
}
if (t == u)
break;
}
gcc_assert (u != NULL_TREE);
/* If the statement list is completely empty, just return it. This is
just as good small as build_empty_stmt, with the advantage that
statement lists are merged when they appended to one another. So
using the STATEMENT_LIST avoids pathological buildup of EMPTY_STMT_P
statements. */
if (TREE_SIDE_EFFECTS (t))
{
tree_stmt_iterator i = tsi_start (t);
/* If the statement list contained exactly one statement, then
extract it immediately. */
if (tsi_one_before_end_p (i))
{
u = tsi_stmt (i);
tsi_delink (&i);
free_stmt_list (t);
t = u;
}
}
return t;
} | /* Finish the statement tree rooted at T. */ | Finish the statement tree rooted at T. | [
"Finish",
"the",
"statement",
"tree",
"rooted",
"at",
"T",
"."
] | tree
pop_stmt_list (tree t)
{
tree u = NULL_TREE;
while (1)
{
u = VEC_pop (tree, stmt_list_stack);
if (!VEC_empty (tree, stmt_list_stack))
{
tree x = VEC_last (tree, stmt_list_stack);
STATEMENT_LIST_HAS_LABEL (x) |= STATEMENT_LIST_HAS_LABEL (u);
}
if (t == u)
break;
}
gcc_assert (u != NULL_TREE);
if (TREE_SIDE_EFFECTS (t))
{
tree_stmt_iterator i = tsi_start (t);
if (tsi_one_before_end_p (i))
{
u = tsi_stmt (i);
tsi_delink (&i);
free_stmt_list (t);
t = u;
}
}
return t;
} | [
"tree",
"pop_stmt_list",
"(",
"tree",
"t",
")",
"{",
"tree",
"u",
"=",
"NULL_TREE",
";",
"while",
"(",
"1",
")",
"{",
"u",
"=",
"VEC_pop",
"(",
"tree",
",",
"stmt_list_stack",
")",
";",
"if",
"(",
"!",
"VEC_empty",
"(",
"tree",
",",
"stmt_list_stack",
")",
")",
"{",
"tree",
"x",
"=",
"VEC_last",
"(",
"tree",
",",
"stmt_list_stack",
")",
";",
"STATEMENT_LIST_HAS_LABEL",
"(",
"x",
")",
"|=",
"STATEMENT_LIST_HAS_LABEL",
"(",
"u",
")",
";",
"}",
"if",
"(",
"t",
"==",
"u",
")",
"break",
";",
"}",
"gcc_assert",
"(",
"u",
"!=",
"NULL_TREE",
")",
";",
"if",
"(",
"TREE_SIDE_EFFECTS",
"(",
"t",
")",
")",
"{",
"tree_stmt_iterator",
"i",
"=",
"tsi_start",
"(",
"t",
")",
";",
"if",
"(",
"tsi_one_before_end_p",
"(",
"i",
")",
")",
"{",
"u",
"=",
"tsi_stmt",
"(",
"i",
")",
";",
"tsi_delink",
"(",
"&",
"i",
")",
";",
"free_stmt_list",
"(",
"t",
")",
";",
"t",
"=",
"u",
";",
"}",
"}",
"return",
"t",
";",
"}"
] | Finish the statement tree rooted at T. | [
"Finish",
"the",
"statement",
"tree",
"rooted",
"at",
"T",
"."
] | [
"/* Pop statement lists until we reach the target level. The extra\n nestings will be due to outstanding cleanups. */",
"/* If the statement list is completely empty, just return it. This is\n just as good small as build_empty_stmt, with the advantage that\n statement lists are merged when they appended to one another. So\n using the STATEMENT_LIST avoids pathological buildup of EMPTY_STMT_P\n statements. */",
"/* If the statement list contained exactly one statement, then\n\t extract it immediately. */"
] | [
{
"param": "t",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "t",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
cb0f2be314e8f87be62bdca9a18ef8bb8da4eaa1 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/c-family/c-semantics.c | [
"BSD-3-Clause"
] | C | build_real_imag_expr | tree | tree
build_real_imag_expr (location_t location, enum tree_code code, tree arg)
{
tree ret;
tree arg_type = TREE_TYPE (arg);
gcc_assert (code == REALPART_EXPR || code == IMAGPART_EXPR);
if (TREE_CODE (arg_type) == COMPLEX_TYPE)
{
ret = build1 (code, TREE_TYPE (TREE_TYPE (arg)), arg);
SET_EXPR_LOCATION (ret, location);
}
else if (INTEGRAL_TYPE_P (arg_type) || SCALAR_FLOAT_TYPE_P (arg_type))
{
ret = (code == REALPART_EXPR
? arg
: omit_one_operand_loc (location, arg_type,
integer_zero_node, arg));
}
else
{
error_at (location, "wrong type argument to %s",
code == REALPART_EXPR ? "__real" : "__imag");
ret = error_mark_node;
}
return ret;
} | /* Build a REALPART_EXPR or IMAGPART_EXPR, according to CODE, from ARG. */ | Build a REALPART_EXPR or IMAGPART_EXPR, according to CODE, from ARG. | [
"Build",
"a",
"REALPART_EXPR",
"or",
"IMAGPART_EXPR",
"according",
"to",
"CODE",
"from",
"ARG",
"."
] | tree
build_real_imag_expr (location_t location, enum tree_code code, tree arg)
{
tree ret;
tree arg_type = TREE_TYPE (arg);
gcc_assert (code == REALPART_EXPR || code == IMAGPART_EXPR);
if (TREE_CODE (arg_type) == COMPLEX_TYPE)
{
ret = build1 (code, TREE_TYPE (TREE_TYPE (arg)), arg);
SET_EXPR_LOCATION (ret, location);
}
else if (INTEGRAL_TYPE_P (arg_type) || SCALAR_FLOAT_TYPE_P (arg_type))
{
ret = (code == REALPART_EXPR
? arg
: omit_one_operand_loc (location, arg_type,
integer_zero_node, arg));
}
else
{
error_at (location, "wrong type argument to %s",
code == REALPART_EXPR ? "__real" : "__imag");
ret = error_mark_node;
}
return ret;
} | [
"tree",
"build_real_imag_expr",
"(",
"location_t",
"location",
",",
"enum",
"tree_code",
"code",
",",
"tree",
"arg",
")",
"{",
"tree",
"ret",
";",
"tree",
"arg_type",
"=",
"TREE_TYPE",
"(",
"arg",
")",
";",
"gcc_assert",
"(",
"code",
"==",
"REALPART_EXPR",
"||",
"code",
"==",
"IMAGPART_EXPR",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"arg_type",
")",
"==",
"COMPLEX_TYPE",
")",
"{",
"ret",
"=",
"build1",
"(",
"code",
",",
"TREE_TYPE",
"(",
"TREE_TYPE",
"(",
"arg",
")",
")",
",",
"arg",
")",
";",
"SET_EXPR_LOCATION",
"(",
"ret",
",",
"location",
")",
";",
"}",
"else",
"if",
"(",
"INTEGRAL_TYPE_P",
"(",
"arg_type",
")",
"||",
"SCALAR_FLOAT_TYPE_P",
"(",
"arg_type",
")",
")",
"{",
"ret",
"=",
"(",
"code",
"==",
"REALPART_EXPR",
"?",
"arg",
":",
"omit_one_operand_loc",
"(",
"location",
",",
"arg_type",
",",
"integer_zero_node",
",",
"arg",
")",
")",
";",
"}",
"else",
"{",
"error_at",
"(",
"location",
",",
"\"",
"\"",
",",
"code",
"==",
"REALPART_EXPR",
"?",
"\"",
"\"",
":",
"\"",
"\"",
")",
";",
"ret",
"=",
"error_mark_node",
";",
"}",
"return",
"ret",
";",
"}"
] | Build a REALPART_EXPR or IMAGPART_EXPR, according to CODE, from ARG. | [
"Build",
"a",
"REALPART_EXPR",
"or",
"IMAGPART_EXPR",
"according",
"to",
"CODE",
"from",
"ARG",
"."
] | [] | [
{
"param": "location",
"type": "location_t"
},
{
"param": "code",
"type": "enum tree_code"
},
{
"param": "arg",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "location",
"type": "location_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "code",
"type": "enum tree_code",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "arg",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | change_return_type | tree | tree
change_return_type (tree new_ret, tree fntype)
{
tree newtype;
tree args = TYPE_ARG_TYPES (fntype);
tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
tree attrs = TYPE_ATTRIBUTES (fntype);
if (same_type_p (new_ret, TREE_TYPE (fntype)))
return fntype;
if (TREE_CODE (fntype) == FUNCTION_TYPE)
{
newtype = build_function_type (new_ret, args);
newtype = apply_memfn_quals (newtype, type_memfn_quals (fntype));
}
else
newtype = build_method_type_directly
(class_of_this_parm (fntype), new_ret, TREE_CHAIN (args));
if (raises)
newtype = build_exception_variant (newtype, raises);
if (attrs)
newtype = cp_build_type_attribute_variant (newtype, attrs);
return newtype;
} | /* Return a variant of FNTYPE, a FUNCTION_TYPE or METHOD_TYPE, with its
return type changed to NEW_RET. */ | Return a variant of FNTYPE, a FUNCTION_TYPE or METHOD_TYPE, with its
return type changed to NEW_RET. | [
"Return",
"a",
"variant",
"of",
"FNTYPE",
"a",
"FUNCTION_TYPE",
"or",
"METHOD_TYPE",
"with",
"its",
"return",
"type",
"changed",
"to",
"NEW_RET",
"."
] | tree
change_return_type (tree new_ret, tree fntype)
{
tree newtype;
tree args = TYPE_ARG_TYPES (fntype);
tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
tree attrs = TYPE_ATTRIBUTES (fntype);
if (same_type_p (new_ret, TREE_TYPE (fntype)))
return fntype;
if (TREE_CODE (fntype) == FUNCTION_TYPE)
{
newtype = build_function_type (new_ret, args);
newtype = apply_memfn_quals (newtype, type_memfn_quals (fntype));
}
else
newtype = build_method_type_directly
(class_of_this_parm (fntype), new_ret, TREE_CHAIN (args));
if (raises)
newtype = build_exception_variant (newtype, raises);
if (attrs)
newtype = cp_build_type_attribute_variant (newtype, attrs);
return newtype;
} | [
"tree",
"change_return_type",
"(",
"tree",
"new_ret",
",",
"tree",
"fntype",
")",
"{",
"tree",
"newtype",
";",
"tree",
"args",
"=",
"TYPE_ARG_TYPES",
"(",
"fntype",
")",
";",
"tree",
"raises",
"=",
"TYPE_RAISES_EXCEPTIONS",
"(",
"fntype",
")",
";",
"tree",
"attrs",
"=",
"TYPE_ATTRIBUTES",
"(",
"fntype",
")",
";",
"if",
"(",
"same_type_p",
"(",
"new_ret",
",",
"TREE_TYPE",
"(",
"fntype",
")",
")",
")",
"return",
"fntype",
";",
"if",
"(",
"TREE_CODE",
"(",
"fntype",
")",
"==",
"FUNCTION_TYPE",
")",
"{",
"newtype",
"=",
"build_function_type",
"(",
"new_ret",
",",
"args",
")",
";",
"newtype",
"=",
"apply_memfn_quals",
"(",
"newtype",
",",
"type_memfn_quals",
"(",
"fntype",
")",
")",
";",
"}",
"else",
"newtype",
"=",
"build_method_type_directly",
"(",
"class_of_this_parm",
"(",
"fntype",
")",
",",
"new_ret",
",",
"TREE_CHAIN",
"(",
"args",
")",
")",
";",
"if",
"(",
"raises",
")",
"newtype",
"=",
"build_exception_variant",
"(",
"newtype",
",",
"raises",
")",
";",
"if",
"(",
"attrs",
")",
"newtype",
"=",
"cp_build_type_attribute_variant",
"(",
"newtype",
",",
"attrs",
")",
";",
"return",
"newtype",
";",
"}"
] | Return a variant of FNTYPE, a FUNCTION_TYPE or METHOD_TYPE, with its
return type changed to NEW_RET. | [
"Return",
"a",
"variant",
"of",
"FNTYPE",
"a",
"FUNCTION_TYPE",
"or",
"METHOD_TYPE",
"with",
"its",
"return",
"type",
"changed",
"to",
"NEW_RET",
"."
] | [] | [
{
"param": "new_ret",
"type": "tree"
},
{
"param": "fntype",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "new_ret",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "fntype",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | cp_build_parm_decl | tree | tree
cp_build_parm_decl (tree name, tree type)
{
tree parm = build_decl (input_location,
PARM_DECL, name, type);
/* DECL_ARG_TYPE is only used by the back end and the back end never
sees templates. */
if (!processing_template_decl)
DECL_ARG_TYPE (parm) = type_passed_as (type);
/* If the type is a pack expansion, then we have a function
parameter pack. */
if (type && TREE_CODE (type) == TYPE_PACK_EXPANSION)
FUNCTION_PARAMETER_PACK_P (parm) = 1;
return parm;
} | /* Build a PARM_DECL with NAME and TYPE, and set DECL_ARG_TYPE
appropriately. */ | Build a PARM_DECL with NAME and TYPE, and set DECL_ARG_TYPE
appropriately. | [
"Build",
"a",
"PARM_DECL",
"with",
"NAME",
"and",
"TYPE",
"and",
"set",
"DECL_ARG_TYPE",
"appropriately",
"."
] | tree
cp_build_parm_decl (tree name, tree type)
{
tree parm = build_decl (input_location,
PARM_DECL, name, type);
if (!processing_template_decl)
DECL_ARG_TYPE (parm) = type_passed_as (type);
if (type && TREE_CODE (type) == TYPE_PACK_EXPANSION)
FUNCTION_PARAMETER_PACK_P (parm) = 1;
return parm;
} | [
"tree",
"cp_build_parm_decl",
"(",
"tree",
"name",
",",
"tree",
"type",
")",
"{",
"tree",
"parm",
"=",
"build_decl",
"(",
"input_location",
",",
"PARM_DECL",
",",
"name",
",",
"type",
")",
";",
"if",
"(",
"!",
"processing_template_decl",
")",
"DECL_ARG_TYPE",
"(",
"parm",
")",
"=",
"type_passed_as",
"(",
"type",
")",
";",
"if",
"(",
"type",
"&&",
"TREE_CODE",
"(",
"type",
")",
"==",
"TYPE_PACK_EXPANSION",
")",
"FUNCTION_PARAMETER_PACK_P",
"(",
"parm",
")",
"=",
"1",
";",
"return",
"parm",
";",
"}"
] | Build a PARM_DECL with NAME and TYPE, and set DECL_ARG_TYPE
appropriately. | [
"Build",
"a",
"PARM_DECL",
"with",
"NAME",
"and",
"TYPE",
"and",
"set",
"DECL_ARG_TYPE",
"appropriately",
"."
] | [
"/* DECL_ARG_TYPE is only used by the back end and the back end never\n sees templates. */",
"/* If the type is a pack expansion, then we have a function\n parameter pack. */"
] | [
{
"param": "name",
"type": "tree"
},
{
"param": "type",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "name",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "type",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | build_artificial_parm | tree | tree
build_artificial_parm (tree name, tree type)
{
tree parm = cp_build_parm_decl (name, type);
DECL_ARTIFICIAL (parm) = 1;
/* All our artificial parms are implicitly `const'; they cannot be
assigned to. */
TREE_READONLY (parm) = 1;
return parm;
} | /* Returns a PARM_DECL for a parameter of the indicated TYPE, with the
indicated NAME. */ | Returns a PARM_DECL for a parameter of the indicated TYPE, with the
indicated NAME. | [
"Returns",
"a",
"PARM_DECL",
"for",
"a",
"parameter",
"of",
"the",
"indicated",
"TYPE",
"with",
"the",
"indicated",
"NAME",
"."
] | tree
build_artificial_parm (tree name, tree type)
{
tree parm = cp_build_parm_decl (name, type);
DECL_ARTIFICIAL (parm) = 1;
TREE_READONLY (parm) = 1;
return parm;
} | [
"tree",
"build_artificial_parm",
"(",
"tree",
"name",
",",
"tree",
"type",
")",
"{",
"tree",
"parm",
"=",
"cp_build_parm_decl",
"(",
"name",
",",
"type",
")",
";",
"DECL_ARTIFICIAL",
"(",
"parm",
")",
"=",
"1",
";",
"TREE_READONLY",
"(",
"parm",
")",
"=",
"1",
";",
"return",
"parm",
";",
"}"
] | Returns a PARM_DECL for a parameter of the indicated TYPE, with the
indicated NAME. | [
"Returns",
"a",
"PARM_DECL",
"for",
"a",
"parameter",
"of",
"the",
"indicated",
"TYPE",
"with",
"the",
"indicated",
"NAME",
"."
] | [
"/* All our artificial parms are implicitly `const'; they cannot be\n assigned to. */"
] | [
{
"param": "name",
"type": "tree"
},
{
"param": "type",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "name",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "type",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | maybe_retrofit_in_chrg | void | void
maybe_retrofit_in_chrg (tree fn)
{
tree basetype, arg_types, parms, parm, fntype;
/* If we've already add the in-charge parameter don't do it again. */
if (DECL_HAS_IN_CHARGE_PARM_P (fn))
return;
/* When processing templates we can't know, in general, whether or
not we're going to have virtual baseclasses. */
if (processing_template_decl)
return;
/* We don't need an in-charge parameter for constructors that don't
have virtual bases. */
if (DECL_CONSTRUCTOR_P (fn)
&& !CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
return;
arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
basetype = TREE_TYPE (TREE_VALUE (arg_types));
arg_types = TREE_CHAIN (arg_types);
parms = DECL_CHAIN (DECL_ARGUMENTS (fn));
/* If this is a subobject constructor or destructor, our caller will
pass us a pointer to our VTT. */
if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
{
parm = build_artificial_parm (vtt_parm_identifier, vtt_parm_type);
/* First add it to DECL_ARGUMENTS between 'this' and the real args... */
DECL_CHAIN (parm) = parms;
parms = parm;
/* ...and then to TYPE_ARG_TYPES. */
arg_types = hash_tree_chain (vtt_parm_type, arg_types);
DECL_HAS_VTT_PARM_P (fn) = 1;
}
/* Then add the in-charge parm (before the VTT parm). */
parm = build_artificial_parm (in_charge_identifier, integer_type_node);
DECL_CHAIN (parm) = parms;
parms = parm;
arg_types = hash_tree_chain (integer_type_node, arg_types);
/* Insert our new parameter(s) into the list. */
DECL_CHAIN (DECL_ARGUMENTS (fn)) = parms;
/* And rebuild the function type. */
fntype = build_method_type_directly (basetype, TREE_TYPE (TREE_TYPE (fn)),
arg_types);
if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))
fntype = build_exception_variant (fntype,
TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)));
if (TYPE_ATTRIBUTES (TREE_TYPE (fn)))
fntype = (cp_build_type_attribute_variant
(fntype, TYPE_ATTRIBUTES (TREE_TYPE (fn))));
TREE_TYPE (fn) = fntype;
/* Now we've got the in-charge parameter. */
DECL_HAS_IN_CHARGE_PARM_P (fn) = 1;
} | /* Constructors for types with virtual baseclasses need an "in-charge" flag
saying whether this constructor is responsible for initialization of
virtual baseclasses or not. All destructors also need this "in-charge"
flag, which additionally determines whether or not the destructor should
free the memory for the object.
This function adds the "in-charge" flag to member function FN if
appropriate. It is called from grokclassfn and tsubst.
FN must be either a constructor or destructor.
The in-charge flag follows the 'this' parameter, and is followed by the
VTT parm (if any), then the user-written parms. */ | Constructors for types with virtual baseclasses need an "in-charge" flag
saying whether this constructor is responsible for initialization of
virtual baseclasses or not. All destructors also need this "in-charge"
flag, which additionally determines whether or not the destructor should
free the memory for the object.
This function adds the "in-charge" flag to member function FN if
appropriate. It is called from grokclassfn and tsubst.
FN must be either a constructor or destructor.
The in-charge flag follows the 'this' parameter, and is followed by the
VTT parm (if any), then the user-written parms. | [
"Constructors",
"for",
"types",
"with",
"virtual",
"baseclasses",
"need",
"an",
"\"",
"in",
"-",
"charge",
"\"",
"flag",
"saying",
"whether",
"this",
"constructor",
"is",
"responsible",
"for",
"initialization",
"of",
"virtual",
"baseclasses",
"or",
"not",
".",
"All",
"destructors",
"also",
"need",
"this",
"\"",
"in",
"-",
"charge",
"\"",
"flag",
"which",
"additionally",
"determines",
"whether",
"or",
"not",
"the",
"destructor",
"should",
"free",
"the",
"memory",
"for",
"the",
"object",
".",
"This",
"function",
"adds",
"the",
"\"",
"in",
"-",
"charge",
"\"",
"flag",
"to",
"member",
"function",
"FN",
"if",
"appropriate",
".",
"It",
"is",
"called",
"from",
"grokclassfn",
"and",
"tsubst",
".",
"FN",
"must",
"be",
"either",
"a",
"constructor",
"or",
"destructor",
".",
"The",
"in",
"-",
"charge",
"flag",
"follows",
"the",
"'",
"this",
"'",
"parameter",
"and",
"is",
"followed",
"by",
"the",
"VTT",
"parm",
"(",
"if",
"any",
")",
"then",
"the",
"user",
"-",
"written",
"parms",
"."
] | void
maybe_retrofit_in_chrg (tree fn)
{
tree basetype, arg_types, parms, parm, fntype;
if (DECL_HAS_IN_CHARGE_PARM_P (fn))
return;
if (processing_template_decl)
return;
if (DECL_CONSTRUCTOR_P (fn)
&& !CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
return;
arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
basetype = TREE_TYPE (TREE_VALUE (arg_types));
arg_types = TREE_CHAIN (arg_types);
parms = DECL_CHAIN (DECL_ARGUMENTS (fn));
if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
{
parm = build_artificial_parm (vtt_parm_identifier, vtt_parm_type);
DECL_CHAIN (parm) = parms;
parms = parm;
arg_types = hash_tree_chain (vtt_parm_type, arg_types);
DECL_HAS_VTT_PARM_P (fn) = 1;
}
parm = build_artificial_parm (in_charge_identifier, integer_type_node);
DECL_CHAIN (parm) = parms;
parms = parm;
arg_types = hash_tree_chain (integer_type_node, arg_types);
DECL_CHAIN (DECL_ARGUMENTS (fn)) = parms;
fntype = build_method_type_directly (basetype, TREE_TYPE (TREE_TYPE (fn)),
arg_types);
if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))
fntype = build_exception_variant (fntype,
TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)));
if (TYPE_ATTRIBUTES (TREE_TYPE (fn)))
fntype = (cp_build_type_attribute_variant
(fntype, TYPE_ATTRIBUTES (TREE_TYPE (fn))));
TREE_TYPE (fn) = fntype;
DECL_HAS_IN_CHARGE_PARM_P (fn) = 1;
} | [
"void",
"maybe_retrofit_in_chrg",
"(",
"tree",
"fn",
")",
"{",
"tree",
"basetype",
",",
"arg_types",
",",
"parms",
",",
"parm",
",",
"fntype",
";",
"if",
"(",
"DECL_HAS_IN_CHARGE_PARM_P",
"(",
"fn",
")",
")",
"return",
";",
"if",
"(",
"processing_template_decl",
")",
"return",
";",
"if",
"(",
"DECL_CONSTRUCTOR_P",
"(",
"fn",
")",
"&&",
"!",
"CLASSTYPE_VBASECLASSES",
"(",
"DECL_CONTEXT",
"(",
"fn",
")",
")",
")",
"return",
";",
"arg_types",
"=",
"TYPE_ARG_TYPES",
"(",
"TREE_TYPE",
"(",
"fn",
")",
")",
";",
"basetype",
"=",
"TREE_TYPE",
"(",
"TREE_VALUE",
"(",
"arg_types",
")",
")",
";",
"arg_types",
"=",
"TREE_CHAIN",
"(",
"arg_types",
")",
";",
"parms",
"=",
"DECL_CHAIN",
"(",
"DECL_ARGUMENTS",
"(",
"fn",
")",
")",
";",
"if",
"(",
"CLASSTYPE_VBASECLASSES",
"(",
"DECL_CONTEXT",
"(",
"fn",
")",
")",
")",
"{",
"parm",
"=",
"build_artificial_parm",
"(",
"vtt_parm_identifier",
",",
"vtt_parm_type",
")",
";",
"DECL_CHAIN",
"(",
"parm",
")",
"=",
"parms",
";",
"parms",
"=",
"parm",
";",
"arg_types",
"=",
"hash_tree_chain",
"(",
"vtt_parm_type",
",",
"arg_types",
")",
";",
"DECL_HAS_VTT_PARM_P",
"(",
"fn",
")",
"=",
"1",
";",
"}",
"parm",
"=",
"build_artificial_parm",
"(",
"in_charge_identifier",
",",
"integer_type_node",
")",
";",
"DECL_CHAIN",
"(",
"parm",
")",
"=",
"parms",
";",
"parms",
"=",
"parm",
";",
"arg_types",
"=",
"hash_tree_chain",
"(",
"integer_type_node",
",",
"arg_types",
")",
";",
"DECL_CHAIN",
"(",
"DECL_ARGUMENTS",
"(",
"fn",
")",
")",
"=",
"parms",
";",
"fntype",
"=",
"build_method_type_directly",
"(",
"basetype",
",",
"TREE_TYPE",
"(",
"TREE_TYPE",
"(",
"fn",
")",
")",
",",
"arg_types",
")",
";",
"if",
"(",
"TYPE_RAISES_EXCEPTIONS",
"(",
"TREE_TYPE",
"(",
"fn",
")",
")",
")",
"fntype",
"=",
"build_exception_variant",
"(",
"fntype",
",",
"TYPE_RAISES_EXCEPTIONS",
"(",
"TREE_TYPE",
"(",
"fn",
")",
")",
")",
";",
"if",
"(",
"TYPE_ATTRIBUTES",
"(",
"TREE_TYPE",
"(",
"fn",
")",
")",
")",
"fntype",
"=",
"(",
"cp_build_type_attribute_variant",
"(",
"fntype",
",",
"TYPE_ATTRIBUTES",
"(",
"TREE_TYPE",
"(",
"fn",
")",
")",
")",
")",
";",
"TREE_TYPE",
"(",
"fn",
")",
"=",
"fntype",
";",
"DECL_HAS_IN_CHARGE_PARM_P",
"(",
"fn",
")",
"=",
"1",
";",
"}"
] | Constructors for types with virtual baseclasses need an "in-charge" flag
saying whether this constructor is responsible for initialization of
virtual baseclasses or not. | [
"Constructors",
"for",
"types",
"with",
"virtual",
"baseclasses",
"need",
"an",
"\"",
"in",
"-",
"charge",
"\"",
"flag",
"saying",
"whether",
"this",
"constructor",
"is",
"responsible",
"for",
"initialization",
"of",
"virtual",
"baseclasses",
"or",
"not",
"."
] | [
"/* If we've already add the in-charge parameter don't do it again. */",
"/* When processing templates we can't know, in general, whether or\n not we're going to have virtual baseclasses. */",
"/* We don't need an in-charge parameter for constructors that don't\n have virtual bases. */",
"/* If this is a subobject constructor or destructor, our caller will\n pass us a pointer to our VTT. */",
"/* First add it to DECL_ARGUMENTS between 'this' and the real args... */",
"/* ...and then to TYPE_ARG_TYPES. */",
"/* Then add the in-charge parm (before the VTT parm). */",
"/* Insert our new parameter(s) into the list. */",
"/* And rebuild the function type. */",
"/* Now we've got the in-charge parameter. */"
] | [
{
"param": "fn",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "fn",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | grokclassfn | void | void
grokclassfn (tree ctype, tree function, enum overload_flags flags)
{
tree fn_name = DECL_NAME (function);
/* Even within an `extern "C"' block, members get C++ linkage. See
[dcl.link] for details. */
SET_DECL_LANGUAGE (function, lang_cplusplus);
if (fn_name == NULL_TREE)
{
error ("name missing for member function");
fn_name = get_identifier ("<anonymous>");
DECL_NAME (function) = fn_name;
}
DECL_CONTEXT (function) = ctype;
if (flags == DTOR_FLAG)
DECL_DESTRUCTOR_P (function) = 1;
if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function))
maybe_retrofit_in_chrg (function);
} | /* Classes overload their constituent function names automatically.
When a function name is declared in a record structure,
its name is changed to it overloaded name. Since names for
constructors and destructors can conflict, we place a leading
'$' for destructors.
CNAME is the name of the class we are grokking for.
FUNCTION is a FUNCTION_DECL. It was created by `grokdeclarator'.
FLAGS contains bits saying what's special about today's
arguments. DTOR_FLAG == DESTRUCTOR.
If FUNCTION is a destructor, then we must add the `auto-delete' field
as a second parameter. There is some hair associated with the fact
that we must "declare" this variable in the manner consistent with the
way the rest of the arguments were declared.
QUALS are the qualifiers for the this pointer. */ | Classes overload their constituent function names automatically.
When a function name is declared in a record structure,
its name is changed to it overloaded name. Since names for
constructors and destructors can conflict, we place a leading
'$' for destructors.
CNAME is the name of the class we are grokking for.
FUNCTION is a FUNCTION_DECL. It was created by `grokdeclarator'.
FLAGS contains bits saying what's special about today's
arguments.
If FUNCTION is a destructor, then we must add the `auto-delete' field
as a second parameter. There is some hair associated with the fact
that we must "declare" this variable in the manner consistent with the
way the rest of the arguments were declared.
QUALS are the qualifiers for the this pointer. | [
"Classes",
"overload",
"their",
"constituent",
"function",
"names",
"automatically",
".",
"When",
"a",
"function",
"name",
"is",
"declared",
"in",
"a",
"record",
"structure",
"its",
"name",
"is",
"changed",
"to",
"it",
"overloaded",
"name",
".",
"Since",
"names",
"for",
"constructors",
"and",
"destructors",
"can",
"conflict",
"we",
"place",
"a",
"leading",
"'",
"$",
"'",
"for",
"destructors",
".",
"CNAME",
"is",
"the",
"name",
"of",
"the",
"class",
"we",
"are",
"grokking",
"for",
".",
"FUNCTION",
"is",
"a",
"FUNCTION_DECL",
".",
"It",
"was",
"created",
"by",
"`",
"grokdeclarator",
"'",
".",
"FLAGS",
"contains",
"bits",
"saying",
"what",
"'",
"s",
"special",
"about",
"today",
"'",
"s",
"arguments",
".",
"If",
"FUNCTION",
"is",
"a",
"destructor",
"then",
"we",
"must",
"add",
"the",
"`",
"auto",
"-",
"delete",
"'",
"field",
"as",
"a",
"second",
"parameter",
".",
"There",
"is",
"some",
"hair",
"associated",
"with",
"the",
"fact",
"that",
"we",
"must",
"\"",
"declare",
"\"",
"this",
"variable",
"in",
"the",
"manner",
"consistent",
"with",
"the",
"way",
"the",
"rest",
"of",
"the",
"arguments",
"were",
"declared",
".",
"QUALS",
"are",
"the",
"qualifiers",
"for",
"the",
"this",
"pointer",
"."
] | void
grokclassfn (tree ctype, tree function, enum overload_flags flags)
{
tree fn_name = DECL_NAME (function);
SET_DECL_LANGUAGE (function, lang_cplusplus);
if (fn_name == NULL_TREE)
{
error ("name missing for member function");
fn_name = get_identifier ("<anonymous>");
DECL_NAME (function) = fn_name;
}
DECL_CONTEXT (function) = ctype;
if (flags == DTOR_FLAG)
DECL_DESTRUCTOR_P (function) = 1;
if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function))
maybe_retrofit_in_chrg (function);
} | [
"void",
"grokclassfn",
"(",
"tree",
"ctype",
",",
"tree",
"function",
",",
"enum",
"overload_flags",
"flags",
")",
"{",
"tree",
"fn_name",
"=",
"DECL_NAME",
"(",
"function",
")",
";",
"SET_DECL_LANGUAGE",
"(",
"function",
",",
"lang_cplusplus",
")",
";",
"if",
"(",
"fn_name",
"==",
"NULL_TREE",
")",
"{",
"error",
"(",
"\"",
"\"",
")",
";",
"fn_name",
"=",
"get_identifier",
"(",
"\"",
"\"",
")",
";",
"DECL_NAME",
"(",
"function",
")",
"=",
"fn_name",
";",
"}",
"DECL_CONTEXT",
"(",
"function",
")",
"=",
"ctype",
";",
"if",
"(",
"flags",
"==",
"DTOR_FLAG",
")",
"DECL_DESTRUCTOR_P",
"(",
"function",
")",
"=",
"1",
";",
"if",
"(",
"flags",
"==",
"DTOR_FLAG",
"||",
"DECL_CONSTRUCTOR_P",
"(",
"function",
")",
")",
"maybe_retrofit_in_chrg",
"(",
"function",
")",
";",
"}"
] | Classes overload their constituent function names automatically. | [
"Classes",
"overload",
"their",
"constituent",
"function",
"names",
"automatically",
"."
] | [
"/* Even within an `extern \"C\"' block, members get C++ linkage. See\n [dcl.link] for details. */"
] | [
{
"param": "ctype",
"type": "tree"
},
{
"param": "function",
"type": "tree"
},
{
"param": "flags",
"type": "enum overload_flags"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "ctype",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "function",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "flags",
"type": "enum overload_flags",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | grok_array_decl | tree | tree
grok_array_decl (tree array_expr, tree index_exp)
{
tree type;
tree expr;
tree orig_array_expr = array_expr;
tree orig_index_exp = index_exp;
if (error_operand_p (array_expr) || error_operand_p (index_exp))
return error_mark_node;
if (processing_template_decl)
{
if (type_dependent_expression_p (array_expr)
|| type_dependent_expression_p (index_exp))
return build_min_nt (ARRAY_REF, array_expr, index_exp,
NULL_TREE, NULL_TREE);
array_expr = build_non_dependent_expr (array_expr);
index_exp = build_non_dependent_expr (index_exp);
}
type = TREE_TYPE (array_expr);
gcc_assert (type);
type = non_reference (type);
/* If they have an `operator[]', use that. */
if (MAYBE_CLASS_TYPE_P (type) || MAYBE_CLASS_TYPE_P (TREE_TYPE (index_exp)))
expr = build_new_op (ARRAY_REF, LOOKUP_NORMAL,
array_expr, index_exp, NULL_TREE,
/*overload=*/NULL, tf_warning_or_error);
else
{
tree p1, p2, i1, i2;
/* Otherwise, create an ARRAY_REF for a pointer or array type.
It is a little-known fact that, if `a' is an array and `i' is
an int, you can write `i[a]', which means the same thing as
`a[i]'. */
if (TREE_CODE (type) == ARRAY_TYPE)
p1 = array_expr;
else
p1 = build_expr_type_conversion (WANT_POINTER, array_expr, false);
if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE)
p2 = index_exp;
else
p2 = build_expr_type_conversion (WANT_POINTER, index_exp, false);
i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr,
false);
i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp,
false);
if ((p1 && i2) && (i1 && p2))
error ("ambiguous conversion for array subscript");
if (p1 && i2)
array_expr = p1, index_exp = i2;
else if (i1 && p2)
array_expr = p2, index_exp = i1;
else
{
error ("invalid types %<%T[%T]%> for array subscript",
type, TREE_TYPE (index_exp));
return error_mark_node;
}
if (array_expr == error_mark_node || index_exp == error_mark_node)
error ("ambiguous conversion for array subscript");
expr = build_array_ref (input_location, array_expr, index_exp);
}
if (processing_template_decl && expr != error_mark_node)
return build_min_non_dep (ARRAY_REF, expr, orig_array_expr, orig_index_exp,
NULL_TREE, NULL_TREE);
return expr;
} | /* Create an ARRAY_REF, checking for the user doing things backwards
along the way. */ | Create an ARRAY_REF, checking for the user doing things backwards
along the way. | [
"Create",
"an",
"ARRAY_REF",
"checking",
"for",
"the",
"user",
"doing",
"things",
"backwards",
"along",
"the",
"way",
"."
] | tree
grok_array_decl (tree array_expr, tree index_exp)
{
tree type;
tree expr;
tree orig_array_expr = array_expr;
tree orig_index_exp = index_exp;
if (error_operand_p (array_expr) || error_operand_p (index_exp))
return error_mark_node;
if (processing_template_decl)
{
if (type_dependent_expression_p (array_expr)
|| type_dependent_expression_p (index_exp))
return build_min_nt (ARRAY_REF, array_expr, index_exp,
NULL_TREE, NULL_TREE);
array_expr = build_non_dependent_expr (array_expr);
index_exp = build_non_dependent_expr (index_exp);
}
type = TREE_TYPE (array_expr);
gcc_assert (type);
type = non_reference (type);
if (MAYBE_CLASS_TYPE_P (type) || MAYBE_CLASS_TYPE_P (TREE_TYPE (index_exp)))
expr = build_new_op (ARRAY_REF, LOOKUP_NORMAL,
array_expr, index_exp, NULL_TREE,
NULL, tf_warning_or_error);
else
{
tree p1, p2, i1, i2;
if (TREE_CODE (type) == ARRAY_TYPE)
p1 = array_expr;
else
p1 = build_expr_type_conversion (WANT_POINTER, array_expr, false);
if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE)
p2 = index_exp;
else
p2 = build_expr_type_conversion (WANT_POINTER, index_exp, false);
i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr,
false);
i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp,
false);
if ((p1 && i2) && (i1 && p2))
error ("ambiguous conversion for array subscript");
if (p1 && i2)
array_expr = p1, index_exp = i2;
else if (i1 && p2)
array_expr = p2, index_exp = i1;
else
{
error ("invalid types %<%T[%T]%> for array subscript",
type, TREE_TYPE (index_exp));
return error_mark_node;
}
if (array_expr == error_mark_node || index_exp == error_mark_node)
error ("ambiguous conversion for array subscript");
expr = build_array_ref (input_location, array_expr, index_exp);
}
if (processing_template_decl && expr != error_mark_node)
return build_min_non_dep (ARRAY_REF, expr, orig_array_expr, orig_index_exp,
NULL_TREE, NULL_TREE);
return expr;
} | [
"tree",
"grok_array_decl",
"(",
"tree",
"array_expr",
",",
"tree",
"index_exp",
")",
"{",
"tree",
"type",
";",
"tree",
"expr",
";",
"tree",
"orig_array_expr",
"=",
"array_expr",
";",
"tree",
"orig_index_exp",
"=",
"index_exp",
";",
"if",
"(",
"error_operand_p",
"(",
"array_expr",
")",
"||",
"error_operand_p",
"(",
"index_exp",
")",
")",
"return",
"error_mark_node",
";",
"if",
"(",
"processing_template_decl",
")",
"{",
"if",
"(",
"type_dependent_expression_p",
"(",
"array_expr",
")",
"||",
"type_dependent_expression_p",
"(",
"index_exp",
")",
")",
"return",
"build_min_nt",
"(",
"ARRAY_REF",
",",
"array_expr",
",",
"index_exp",
",",
"NULL_TREE",
",",
"NULL_TREE",
")",
";",
"array_expr",
"=",
"build_non_dependent_expr",
"(",
"array_expr",
")",
";",
"index_exp",
"=",
"build_non_dependent_expr",
"(",
"index_exp",
")",
";",
"}",
"type",
"=",
"TREE_TYPE",
"(",
"array_expr",
")",
";",
"gcc_assert",
"(",
"type",
")",
";",
"type",
"=",
"non_reference",
"(",
"type",
")",
";",
"if",
"(",
"MAYBE_CLASS_TYPE_P",
"(",
"type",
")",
"||",
"MAYBE_CLASS_TYPE_P",
"(",
"TREE_TYPE",
"(",
"index_exp",
")",
")",
")",
"expr",
"=",
"build_new_op",
"(",
"ARRAY_REF",
",",
"LOOKUP_NORMAL",
",",
"array_expr",
",",
"index_exp",
",",
"NULL_TREE",
",",
"NULL",
",",
"tf_warning_or_error",
")",
";",
"else",
"{",
"tree",
"p1",
",",
"p2",
",",
"i1",
",",
"i2",
";",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"ARRAY_TYPE",
")",
"p1",
"=",
"array_expr",
";",
"else",
"p1",
"=",
"build_expr_type_conversion",
"(",
"WANT_POINTER",
",",
"array_expr",
",",
"false",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"TREE_TYPE",
"(",
"index_exp",
")",
")",
"==",
"ARRAY_TYPE",
")",
"p2",
"=",
"index_exp",
";",
"else",
"p2",
"=",
"build_expr_type_conversion",
"(",
"WANT_POINTER",
",",
"index_exp",
",",
"false",
")",
";",
"i1",
"=",
"build_expr_type_conversion",
"(",
"WANT_INT",
"|",
"WANT_ENUM",
",",
"array_expr",
",",
"false",
")",
";",
"i2",
"=",
"build_expr_type_conversion",
"(",
"WANT_INT",
"|",
"WANT_ENUM",
",",
"index_exp",
",",
"false",
")",
";",
"if",
"(",
"(",
"p1",
"&&",
"i2",
")",
"&&",
"(",
"i1",
"&&",
"p2",
")",
")",
"error",
"(",
"\"",
"\"",
")",
";",
"if",
"(",
"p1",
"&&",
"i2",
")",
"array_expr",
"=",
"p1",
",",
"index_exp",
"=",
"i2",
";",
"else",
"if",
"(",
"i1",
"&&",
"p2",
")",
"array_expr",
"=",
"p2",
",",
"index_exp",
"=",
"i1",
";",
"else",
"{",
"error",
"(",
"\"",
"\"",
",",
"type",
",",
"TREE_TYPE",
"(",
"index_exp",
")",
")",
";",
"return",
"error_mark_node",
";",
"}",
"if",
"(",
"array_expr",
"==",
"error_mark_node",
"||",
"index_exp",
"==",
"error_mark_node",
")",
"error",
"(",
"\"",
"\"",
")",
";",
"expr",
"=",
"build_array_ref",
"(",
"input_location",
",",
"array_expr",
",",
"index_exp",
")",
";",
"}",
"if",
"(",
"processing_template_decl",
"&&",
"expr",
"!=",
"error_mark_node",
")",
"return",
"build_min_non_dep",
"(",
"ARRAY_REF",
",",
"expr",
",",
"orig_array_expr",
",",
"orig_index_exp",
",",
"NULL_TREE",
",",
"NULL_TREE",
")",
";",
"return",
"expr",
";",
"}"
] | Create an ARRAY_REF, checking for the user doing things backwards
along the way. | [
"Create",
"an",
"ARRAY_REF",
"checking",
"for",
"the",
"user",
"doing",
"things",
"backwards",
"along",
"the",
"way",
"."
] | [
"/* If they have an `operator[]', use that. */",
"/*overload=*/",
"/* Otherwise, create an ARRAY_REF for a pointer or array type.\n\t It is a little-known fact that, if `a' is an array and `i' is\n\t an int, you can write `i[a]', which means the same thing as\n\t `a[i]'. */"
] | [
{
"param": "array_expr",
"type": "tree"
},
{
"param": "index_exp",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "array_expr",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "index_exp",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | delete_sanity | tree | tree
delete_sanity (tree exp, tree size, bool doing_vec, int use_global_delete,
tsubst_flags_t complain)
{
tree t, type;
if (exp == error_mark_node)
return exp;
if (processing_template_decl)
{
t = build_min (DELETE_EXPR, void_type_node, exp, size);
DELETE_EXPR_USE_GLOBAL (t) = use_global_delete;
DELETE_EXPR_USE_VEC (t) = doing_vec;
TREE_SIDE_EFFECTS (t) = 1;
return t;
}
/* An array can't have been allocated by new, so complain. */
if (TREE_CODE (exp) == VAR_DECL
&& TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
warning (0, "deleting array %q#D", exp);
t = build_expr_type_conversion (WANT_POINTER, exp, true);
if (t == NULL_TREE || t == error_mark_node)
{
error ("type %q#T argument given to %<delete%>, expected pointer",
TREE_TYPE (exp));
return error_mark_node;
}
type = TREE_TYPE (t);
/* As of Valley Forge, you can delete a pointer to const. */
/* You can't delete functions. */
if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
{
error ("cannot delete a function. Only pointer-to-objects are "
"valid arguments to %<delete%>");
return error_mark_node;
}
/* Deleting ptr to void is undefined behavior [expr.delete/3]. */
if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
{
warning (0, "deleting %qT is undefined", type);
doing_vec = 0;
}
/* Deleting a pointer with the value zero is valid and has no effect. */
if (integer_zerop (t))
return build1 (NOP_EXPR, void_type_node, t);
if (doing_vec)
return build_vec_delete (t, /*maxindex=*/NULL_TREE,
sfk_deleting_destructor,
use_global_delete, complain);
else
return build_delete (type, t, sfk_deleting_destructor,
LOOKUP_NORMAL, use_global_delete,
complain);
} | /* Given the cast expression EXP, checking out its validity. Either return
an error_mark_node if there was an unavoidable error, return a cast to
void for trying to delete a pointer w/ the value 0, or return the
call to delete. If DOING_VEC is true, we handle things differently
for doing an array delete.
Implements ARM $5.3.4. This is called from the parser. */ | Given the cast expression EXP, checking out its validity. Either return
an error_mark_node if there was an unavoidable error, return a cast to
void for trying to delete a pointer w/ the value 0, or return the
call to delete. If DOING_VEC is true, we handle things differently
for doing an array delete. | [
"Given",
"the",
"cast",
"expression",
"EXP",
"checking",
"out",
"its",
"validity",
".",
"Either",
"return",
"an",
"error_mark_node",
"if",
"there",
"was",
"an",
"unavoidable",
"error",
"return",
"a",
"cast",
"to",
"void",
"for",
"trying",
"to",
"delete",
"a",
"pointer",
"w",
"/",
"the",
"value",
"0",
"or",
"return",
"the",
"call",
"to",
"delete",
".",
"If",
"DOING_VEC",
"is",
"true",
"we",
"handle",
"things",
"differently",
"for",
"doing",
"an",
"array",
"delete",
"."
] | tree
delete_sanity (tree exp, tree size, bool doing_vec, int use_global_delete,
tsubst_flags_t complain)
{
tree t, type;
if (exp == error_mark_node)
return exp;
if (processing_template_decl)
{
t = build_min (DELETE_EXPR, void_type_node, exp, size);
DELETE_EXPR_USE_GLOBAL (t) = use_global_delete;
DELETE_EXPR_USE_VEC (t) = doing_vec;
TREE_SIDE_EFFECTS (t) = 1;
return t;
}
if (TREE_CODE (exp) == VAR_DECL
&& TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
warning (0, "deleting array %q#D", exp);
t = build_expr_type_conversion (WANT_POINTER, exp, true);
if (t == NULL_TREE || t == error_mark_node)
{
error ("type %q#T argument given to %<delete%>, expected pointer",
TREE_TYPE (exp));
return error_mark_node;
}
type = TREE_TYPE (t);
if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
{
error ("cannot delete a function. Only pointer-to-objects are "
"valid arguments to %<delete%>");
return error_mark_node;
}
if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
{
warning (0, "deleting %qT is undefined", type);
doing_vec = 0;
}
if (integer_zerop (t))
return build1 (NOP_EXPR, void_type_node, t);
if (doing_vec)
return build_vec_delete (t, NULL_TREE,
sfk_deleting_destructor,
use_global_delete, complain);
else
return build_delete (type, t, sfk_deleting_destructor,
LOOKUP_NORMAL, use_global_delete,
complain);
} | [
"tree",
"delete_sanity",
"(",
"tree",
"exp",
",",
"tree",
"size",
",",
"bool",
"doing_vec",
",",
"int",
"use_global_delete",
",",
"tsubst_flags_t",
"complain",
")",
"{",
"tree",
"t",
",",
"type",
";",
"if",
"(",
"exp",
"==",
"error_mark_node",
")",
"return",
"exp",
";",
"if",
"(",
"processing_template_decl",
")",
"{",
"t",
"=",
"build_min",
"(",
"DELETE_EXPR",
",",
"void_type_node",
",",
"exp",
",",
"size",
")",
";",
"DELETE_EXPR_USE_GLOBAL",
"(",
"t",
")",
"=",
"use_global_delete",
";",
"DELETE_EXPR_USE_VEC",
"(",
"t",
")",
"=",
"doing_vec",
";",
"TREE_SIDE_EFFECTS",
"(",
"t",
")",
"=",
"1",
";",
"return",
"t",
";",
"}",
"if",
"(",
"TREE_CODE",
"(",
"exp",
")",
"==",
"VAR_DECL",
"&&",
"TREE_CODE",
"(",
"TREE_TYPE",
"(",
"exp",
")",
")",
"==",
"ARRAY_TYPE",
")",
"warning",
"(",
"0",
",",
"\"",
"\"",
",",
"exp",
")",
";",
"t",
"=",
"build_expr_type_conversion",
"(",
"WANT_POINTER",
",",
"exp",
",",
"true",
")",
";",
"if",
"(",
"t",
"==",
"NULL_TREE",
"||",
"t",
"==",
"error_mark_node",
")",
"{",
"error",
"(",
"\"",
"\"",
",",
"TREE_TYPE",
"(",
"exp",
")",
")",
";",
"return",
"error_mark_node",
";",
"}",
"type",
"=",
"TREE_TYPE",
"(",
"t",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"TREE_TYPE",
"(",
"type",
")",
")",
"==",
"FUNCTION_TYPE",
")",
"{",
"error",
"(",
"\"",
"\"",
"\"",
"\"",
")",
";",
"return",
"error_mark_node",
";",
"}",
"if",
"(",
"TREE_CODE",
"(",
"TREE_TYPE",
"(",
"type",
")",
")",
"==",
"VOID_TYPE",
")",
"{",
"warning",
"(",
"0",
",",
"\"",
"\"",
",",
"type",
")",
";",
"doing_vec",
"=",
"0",
";",
"}",
"if",
"(",
"integer_zerop",
"(",
"t",
")",
")",
"return",
"build1",
"(",
"NOP_EXPR",
",",
"void_type_node",
",",
"t",
")",
";",
"if",
"(",
"doing_vec",
")",
"return",
"build_vec_delete",
"(",
"t",
",",
"NULL_TREE",
",",
"sfk_deleting_destructor",
",",
"use_global_delete",
",",
"complain",
")",
";",
"else",
"return",
"build_delete",
"(",
"type",
",",
"t",
",",
"sfk_deleting_destructor",
",",
"LOOKUP_NORMAL",
",",
"use_global_delete",
",",
"complain",
")",
";",
"}"
] | Given the cast expression EXP, checking out its validity. | [
"Given",
"the",
"cast",
"expression",
"EXP",
"checking",
"out",
"its",
"validity",
"."
] | [
"/* An array can't have been allocated by new, so complain. */",
"/* As of Valley Forge, you can delete a pointer to const. */",
"/* You can't delete functions. */",
"/* Deleting ptr to void is undefined behavior [expr.delete/3]. */",
"/* Deleting a pointer with the value zero is valid and has no effect. */",
"/*maxindex=*/"
] | [
{
"param": "exp",
"type": "tree"
},
{
"param": "size",
"type": "tree"
},
{
"param": "doing_vec",
"type": "bool"
},
{
"param": "use_global_delete",
"type": "int"
},
{
"param": "complain",
"type": "tsubst_flags_t"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "exp",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "size",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "doing_vec",
"type": "bool",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "use_global_delete",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "complain",
"type": "tsubst_flags_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | check_member_template | void | void
check_member_template (tree tmpl)
{
tree decl;
gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
decl = DECL_TEMPLATE_RESULT (tmpl);
if (TREE_CODE (decl) == FUNCTION_DECL
|| DECL_ALIAS_TEMPLATE_P (tmpl)
|| (TREE_CODE (decl) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (decl))))
{
/* The parser rejects template declarations in local classes. */
gcc_assert (!current_function_decl);
/* The parser rejects any use of virtual in a function template. */
gcc_assert (!(TREE_CODE (decl) == FUNCTION_DECL
&& DECL_VIRTUAL_P (decl)));
/* The debug-information generating code doesn't know what to do
with member templates. */
DECL_IGNORED_P (tmpl) = 1;
}
else
error ("template declaration of %q#D", decl);
} | /* Report an error if the indicated template declaration is not the
sort of thing that should be a member template. */ | Report an error if the indicated template declaration is not the
sort of thing that should be a member template. | [
"Report",
"an",
"error",
"if",
"the",
"indicated",
"template",
"declaration",
"is",
"not",
"the",
"sort",
"of",
"thing",
"that",
"should",
"be",
"a",
"member",
"template",
"."
] | void
check_member_template (tree tmpl)
{
tree decl;
gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
decl = DECL_TEMPLATE_RESULT (tmpl);
if (TREE_CODE (decl) == FUNCTION_DECL
|| DECL_ALIAS_TEMPLATE_P (tmpl)
|| (TREE_CODE (decl) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (decl))))
{
gcc_assert (!current_function_decl);
gcc_assert (!(TREE_CODE (decl) == FUNCTION_DECL
&& DECL_VIRTUAL_P (decl)));
DECL_IGNORED_P (tmpl) = 1;
}
else
error ("template declaration of %q#D", decl);
} | [
"void",
"check_member_template",
"(",
"tree",
"tmpl",
")",
"{",
"tree",
"decl",
";",
"gcc_assert",
"(",
"TREE_CODE",
"(",
"tmpl",
")",
"==",
"TEMPLATE_DECL",
")",
";",
"decl",
"=",
"DECL_TEMPLATE_RESULT",
"(",
"tmpl",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
"||",
"DECL_ALIAS_TEMPLATE_P",
"(",
"tmpl",
")",
"||",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"TYPE_DECL",
"&&",
"MAYBE_CLASS_TYPE_P",
"(",
"TREE_TYPE",
"(",
"decl",
")",
")",
")",
")",
"{",
"gcc_assert",
"(",
"!",
"current_function_decl",
")",
";",
"gcc_assert",
"(",
"!",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
"&&",
"DECL_VIRTUAL_P",
"(",
"decl",
")",
")",
")",
";",
"DECL_IGNORED_P",
"(",
"tmpl",
")",
"=",
"1",
";",
"}",
"else",
"error",
"(",
"\"",
"\"",
",",
"decl",
")",
";",
"}"
] | Report an error if the indicated template declaration is not the
sort of thing that should be a member template. | [
"Report",
"an",
"error",
"if",
"the",
"indicated",
"template",
"declaration",
"is",
"not",
"the",
"sort",
"of",
"thing",
"that",
"should",
"be",
"a",
"member",
"template",
"."
] | [
"/* The parser rejects template declarations in local classes. */",
"/* The parser rejects any use of virtual in a function template. */",
"/* The debug-information generating code doesn't know what to do\n\t with member templates. */"
] | [
{
"param": "tmpl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "tmpl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | acceptable_java_type | bool | static bool
acceptable_java_type (tree type)
{
if (type == error_mark_node)
return false;
if (TREE_CODE (type) == VOID_TYPE || TYPE_FOR_JAVA (type))
return true;
if (TREE_CODE (type) == POINTER_TYPE || TREE_CODE (type) == REFERENCE_TYPE)
{
type = TREE_TYPE (type);
if (TREE_CODE (type) == RECORD_TYPE)
{
tree args; int i;
if (! TYPE_FOR_JAVA (type))
return false;
if (! CLASSTYPE_TEMPLATE_INFO (type))
return true;
args = CLASSTYPE_TI_ARGS (type);
i = TREE_VEC_LENGTH (args);
while (--i >= 0)
{
type = TREE_VEC_ELT (args, i);
if (TREE_CODE (type) == POINTER_TYPE)
type = TREE_TYPE (type);
if (! TYPE_FOR_JAVA (type))
return false;
}
return true;
}
}
return false;
} | /* Return true iff TYPE is a valid Java parameter or return type. */ | Return true iff TYPE is a valid Java parameter or return type. | [
"Return",
"true",
"iff",
"TYPE",
"is",
"a",
"valid",
"Java",
"parameter",
"or",
"return",
"type",
"."
] | static bool
acceptable_java_type (tree type)
{
if (type == error_mark_node)
return false;
if (TREE_CODE (type) == VOID_TYPE || TYPE_FOR_JAVA (type))
return true;
if (TREE_CODE (type) == POINTER_TYPE || TREE_CODE (type) == REFERENCE_TYPE)
{
type = TREE_TYPE (type);
if (TREE_CODE (type) == RECORD_TYPE)
{
tree args; int i;
if (! TYPE_FOR_JAVA (type))
return false;
if (! CLASSTYPE_TEMPLATE_INFO (type))
return true;
args = CLASSTYPE_TI_ARGS (type);
i = TREE_VEC_LENGTH (args);
while (--i >= 0)
{
type = TREE_VEC_ELT (args, i);
if (TREE_CODE (type) == POINTER_TYPE)
type = TREE_TYPE (type);
if (! TYPE_FOR_JAVA (type))
return false;
}
return true;
}
}
return false;
} | [
"static",
"bool",
"acceptable_java_type",
"(",
"tree",
"type",
")",
"{",
"if",
"(",
"type",
"==",
"error_mark_node",
")",
"return",
"false",
";",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"VOID_TYPE",
"||",
"TYPE_FOR_JAVA",
"(",
"type",
")",
")",
"return",
"true",
";",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"POINTER_TYPE",
"||",
"TREE_CODE",
"(",
"type",
")",
"==",
"REFERENCE_TYPE",
")",
"{",
"type",
"=",
"TREE_TYPE",
"(",
"type",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"RECORD_TYPE",
")",
"{",
"tree",
"args",
";",
"int",
"i",
";",
"if",
"(",
"!",
"TYPE_FOR_JAVA",
"(",
"type",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"CLASSTYPE_TEMPLATE_INFO",
"(",
"type",
")",
")",
"return",
"true",
";",
"args",
"=",
"CLASSTYPE_TI_ARGS",
"(",
"type",
")",
";",
"i",
"=",
"TREE_VEC_LENGTH",
"(",
"args",
")",
";",
"while",
"(",
"--",
"i",
">=",
"0",
")",
"{",
"type",
"=",
"TREE_VEC_ELT",
"(",
"args",
",",
"i",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"POINTER_TYPE",
")",
"type",
"=",
"TREE_TYPE",
"(",
"type",
")",
";",
"if",
"(",
"!",
"TYPE_FOR_JAVA",
"(",
"type",
")",
")",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}"
] | Return true iff TYPE is a valid Java parameter or return type. | [
"Return",
"true",
"iff",
"TYPE",
"is",
"a",
"valid",
"Java",
"parameter",
"or",
"return",
"type",
"."
] | [] | [
{
"param": "type",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "type",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | check_java_method | bool | bool
check_java_method (tree method)
{
bool jerr = false;
tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
tree ret_type = TREE_TYPE (TREE_TYPE (method));
if (!acceptable_java_type (ret_type))
{
error ("Java method %qD has non-Java return type %qT",
method, ret_type);
jerr = true;
}
arg_types = TREE_CHAIN (arg_types);
if (DECL_HAS_IN_CHARGE_PARM_P (method))
arg_types = TREE_CHAIN (arg_types);
if (DECL_HAS_VTT_PARM_P (method))
arg_types = TREE_CHAIN (arg_types);
for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types))
{
tree type = TREE_VALUE (arg_types);
if (!acceptable_java_type (type))
{
if (type != error_mark_node)
error ("Java method %qD has non-Java parameter type %qT",
method, type);
jerr = true;
}
}
return !jerr;
} | /* For a METHOD in a Java class CTYPE, return true if
the parameter and return types are valid Java types.
Otherwise, print appropriate error messages, and return false. */ | For a METHOD in a Java class CTYPE, return true if
the parameter and return types are valid Java types.
Otherwise, print appropriate error messages, and return false. | [
"For",
"a",
"METHOD",
"in",
"a",
"Java",
"class",
"CTYPE",
"return",
"true",
"if",
"the",
"parameter",
"and",
"return",
"types",
"are",
"valid",
"Java",
"types",
".",
"Otherwise",
"print",
"appropriate",
"error",
"messages",
"and",
"return",
"false",
"."
] | bool
check_java_method (tree method)
{
bool jerr = false;
tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
tree ret_type = TREE_TYPE (TREE_TYPE (method));
if (!acceptable_java_type (ret_type))
{
error ("Java method %qD has non-Java return type %qT",
method, ret_type);
jerr = true;
}
arg_types = TREE_CHAIN (arg_types);
if (DECL_HAS_IN_CHARGE_PARM_P (method))
arg_types = TREE_CHAIN (arg_types);
if (DECL_HAS_VTT_PARM_P (method))
arg_types = TREE_CHAIN (arg_types);
for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types))
{
tree type = TREE_VALUE (arg_types);
if (!acceptable_java_type (type))
{
if (type != error_mark_node)
error ("Java method %qD has non-Java parameter type %qT",
method, type);
jerr = true;
}
}
return !jerr;
} | [
"bool",
"check_java_method",
"(",
"tree",
"method",
")",
"{",
"bool",
"jerr",
"=",
"false",
";",
"tree",
"arg_types",
"=",
"TYPE_ARG_TYPES",
"(",
"TREE_TYPE",
"(",
"method",
")",
")",
";",
"tree",
"ret_type",
"=",
"TREE_TYPE",
"(",
"TREE_TYPE",
"(",
"method",
")",
")",
";",
"if",
"(",
"!",
"acceptable_java_type",
"(",
"ret_type",
")",
")",
"{",
"error",
"(",
"\"",
"\"",
",",
"method",
",",
"ret_type",
")",
";",
"jerr",
"=",
"true",
";",
"}",
"arg_types",
"=",
"TREE_CHAIN",
"(",
"arg_types",
")",
";",
"if",
"(",
"DECL_HAS_IN_CHARGE_PARM_P",
"(",
"method",
")",
")",
"arg_types",
"=",
"TREE_CHAIN",
"(",
"arg_types",
")",
";",
"if",
"(",
"DECL_HAS_VTT_PARM_P",
"(",
"method",
")",
")",
"arg_types",
"=",
"TREE_CHAIN",
"(",
"arg_types",
")",
";",
"for",
"(",
";",
"arg_types",
"!=",
"NULL_TREE",
";",
"arg_types",
"=",
"TREE_CHAIN",
"(",
"arg_types",
")",
")",
"{",
"tree",
"type",
"=",
"TREE_VALUE",
"(",
"arg_types",
")",
";",
"if",
"(",
"!",
"acceptable_java_type",
"(",
"type",
")",
")",
"{",
"if",
"(",
"type",
"!=",
"error_mark_node",
")",
"error",
"(",
"\"",
"\"",
",",
"method",
",",
"type",
")",
";",
"jerr",
"=",
"true",
";",
"}",
"}",
"return",
"!",
"jerr",
";",
"}"
] | For a METHOD in a Java class CTYPE, return true if
the parameter and return types are valid Java types. | [
"For",
"a",
"METHOD",
"in",
"a",
"Java",
"class",
"CTYPE",
"return",
"true",
"if",
"the",
"parameter",
"and",
"return",
"types",
"are",
"valid",
"Java",
"types",
"."
] | [] | [
{
"param": "method",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "method",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | check_classfn | tree | tree
check_classfn (tree ctype, tree function, tree template_parms)
{
int ix;
bool is_template;
tree pushed_scope;
if (DECL_USE_TEMPLATE (function)
&& !(TREE_CODE (function) == TEMPLATE_DECL
&& DECL_TEMPLATE_SPECIALIZATION (function))
&& DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (function)))
/* Since this is a specialization of a member template,
we're not going to find the declaration in the class.
For example, in:
struct S { template <typename T> void f(T); };
template <> void S::f(int);
we're not going to find `S::f(int)', but there's no
reason we should, either. We let our callers know we didn't
find the method, but we don't complain. */
return NULL_TREE;
/* Basic sanity check: for a template function, the template parameters
either were not passed, or they are the same of DECL_TEMPLATE_PARMS. */
if (TREE_CODE (function) == TEMPLATE_DECL)
{
if (template_parms
&& !comp_template_parms (template_parms,
DECL_TEMPLATE_PARMS (function)))
{
error ("template parameter lists provided don%'t match the "
"template parameters of %qD", function);
return error_mark_node;
}
template_parms = DECL_TEMPLATE_PARMS (function);
}
/* OK, is this a definition of a member template? */
is_template = (template_parms != NULL_TREE);
/* We must enter the scope here, because conversion operators are
named by target type, and type equivalence relies on typenames
resolving within the scope of CTYPE. */
pushed_scope = push_scope (ctype);
ix = class_method_index_for_fn (complete_type (ctype), function);
if (ix >= 0)
{
VEC(tree,gc) *methods = CLASSTYPE_METHOD_VEC (ctype);
tree fndecls, fndecl = 0;
bool is_conv_op;
const char *format = NULL;
for (fndecls = VEC_index (tree, methods, ix);
fndecls; fndecls = OVL_NEXT (fndecls))
{
tree p1, p2;
fndecl = OVL_CURRENT (fndecls);
p1 = TYPE_ARG_TYPES (TREE_TYPE (function));
p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
/* We cannot simply call decls_match because this doesn't
work for static member functions that are pretending to
be methods, and because the name may have been changed by
asm("new_name"). */
/* Get rid of the this parameter on functions that become
static. */
if (DECL_STATIC_FUNCTION_P (fndecl)
&& TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
p1 = TREE_CHAIN (p1);
/* A member template definition only matches a member template
declaration. */
if (is_template != (TREE_CODE (fndecl) == TEMPLATE_DECL))
continue;
if (same_type_p (TREE_TYPE (TREE_TYPE (function)),
TREE_TYPE (TREE_TYPE (fndecl)))
&& compparms (p1, p2)
&& (!is_template
|| comp_template_parms (template_parms,
DECL_TEMPLATE_PARMS (fndecl)))
&& (DECL_TEMPLATE_SPECIALIZATION (function)
== DECL_TEMPLATE_SPECIALIZATION (fndecl))
&& (!DECL_TEMPLATE_SPECIALIZATION (function)
|| (DECL_TI_TEMPLATE (function)
== DECL_TI_TEMPLATE (fndecl))))
break;
}
if (fndecls)
{
if (pushed_scope)
pop_scope (pushed_scope);
return OVL_CURRENT (fndecls);
}
error_at (DECL_SOURCE_LOCATION (function),
"prototype for %q#D does not match any in class %qT",
function, ctype);
is_conv_op = DECL_CONV_FN_P (fndecl);
if (is_conv_op)
ix = CLASSTYPE_FIRST_CONVERSION_SLOT;
fndecls = VEC_index (tree, methods, ix);
while (fndecls)
{
fndecl = OVL_CURRENT (fndecls);
fndecls = OVL_NEXT (fndecls);
if (!fndecls && is_conv_op)
{
if (VEC_length (tree, methods) > (size_t) ++ix)
{
fndecls = VEC_index (tree, methods, ix);
if (!DECL_CONV_FN_P (OVL_CURRENT (fndecls)))
{
fndecls = NULL_TREE;
is_conv_op = false;
}
}
else
is_conv_op = false;
}
if (format)
format = " %+#D";
else if (fndecls)
format = N_("candidates are: %+#D");
else
format = N_("candidate is: %+#D");
error (format, fndecl);
}
}
else if (!COMPLETE_TYPE_P (ctype))
cxx_incomplete_type_error (function, ctype);
else
error ("no %q#D member function declared in class %qT",
function, ctype);
if (pushed_scope)
pop_scope (pushed_scope);
return error_mark_node;
} | /* Sanity check: report error if this function FUNCTION is not
really a member of the class (CTYPE) it is supposed to belong to.
TEMPLATE_PARMS is used to specify the template parameters of a member
template passed as FUNCTION_DECL. If the member template is passed as a
TEMPLATE_DECL, it can be NULL since the parameters can be extracted
from the declaration. If the function is not a function template, it
must be NULL.
It returns the original declaration for the function, NULL_TREE if
no declaration was found, error_mark_node if an error was emitted. */ | Sanity check: report error if this function FUNCTION is not
really a member of the class (CTYPE) it is supposed to belong to.
TEMPLATE_PARMS is used to specify the template parameters of a member
template passed as FUNCTION_DECL. If the member template is passed as a
TEMPLATE_DECL, it can be NULL since the parameters can be extracted
from the declaration. If the function is not a function template, it
must be NULL.
It returns the original declaration for the function, NULL_TREE if
no declaration was found, error_mark_node if an error was emitted. | [
"Sanity",
"check",
":",
"report",
"error",
"if",
"this",
"function",
"FUNCTION",
"is",
"not",
"really",
"a",
"member",
"of",
"the",
"class",
"(",
"CTYPE",
")",
"it",
"is",
"supposed",
"to",
"belong",
"to",
".",
"TEMPLATE_PARMS",
"is",
"used",
"to",
"specify",
"the",
"template",
"parameters",
"of",
"a",
"member",
"template",
"passed",
"as",
"FUNCTION_DECL",
".",
"If",
"the",
"member",
"template",
"is",
"passed",
"as",
"a",
"TEMPLATE_DECL",
"it",
"can",
"be",
"NULL",
"since",
"the",
"parameters",
"can",
"be",
"extracted",
"from",
"the",
"declaration",
".",
"If",
"the",
"function",
"is",
"not",
"a",
"function",
"template",
"it",
"must",
"be",
"NULL",
".",
"It",
"returns",
"the",
"original",
"declaration",
"for",
"the",
"function",
"NULL_TREE",
"if",
"no",
"declaration",
"was",
"found",
"error_mark_node",
"if",
"an",
"error",
"was",
"emitted",
"."
] | tree
check_classfn (tree ctype, tree function, tree template_parms)
{
int ix;
bool is_template;
tree pushed_scope;
if (DECL_USE_TEMPLATE (function)
&& !(TREE_CODE (function) == TEMPLATE_DECL
&& DECL_TEMPLATE_SPECIALIZATION (function))
&& DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (function)))
return NULL_TREE;
if (TREE_CODE (function) == TEMPLATE_DECL)
{
if (template_parms
&& !comp_template_parms (template_parms,
DECL_TEMPLATE_PARMS (function)))
{
error ("template parameter lists provided don%'t match the "
"template parameters of %qD", function);
return error_mark_node;
}
template_parms = DECL_TEMPLATE_PARMS (function);
}
is_template = (template_parms != NULL_TREE);
pushed_scope = push_scope (ctype);
ix = class_method_index_for_fn (complete_type (ctype), function);
if (ix >= 0)
{
VEC(tree,gc) *methods = CLASSTYPE_METHOD_VEC (ctype);
tree fndecls, fndecl = 0;
bool is_conv_op;
const char *format = NULL;
for (fndecls = VEC_index (tree, methods, ix);
fndecls; fndecls = OVL_NEXT (fndecls))
{
tree p1, p2;
fndecl = OVL_CURRENT (fndecls);
p1 = TYPE_ARG_TYPES (TREE_TYPE (function));
p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
if (DECL_STATIC_FUNCTION_P (fndecl)
&& TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
p1 = TREE_CHAIN (p1);
if (is_template != (TREE_CODE (fndecl) == TEMPLATE_DECL))
continue;
if (same_type_p (TREE_TYPE (TREE_TYPE (function)),
TREE_TYPE (TREE_TYPE (fndecl)))
&& compparms (p1, p2)
&& (!is_template
|| comp_template_parms (template_parms,
DECL_TEMPLATE_PARMS (fndecl)))
&& (DECL_TEMPLATE_SPECIALIZATION (function)
== DECL_TEMPLATE_SPECIALIZATION (fndecl))
&& (!DECL_TEMPLATE_SPECIALIZATION (function)
|| (DECL_TI_TEMPLATE (function)
== DECL_TI_TEMPLATE (fndecl))))
break;
}
if (fndecls)
{
if (pushed_scope)
pop_scope (pushed_scope);
return OVL_CURRENT (fndecls);
}
error_at (DECL_SOURCE_LOCATION (function),
"prototype for %q#D does not match any in class %qT",
function, ctype);
is_conv_op = DECL_CONV_FN_P (fndecl);
if (is_conv_op)
ix = CLASSTYPE_FIRST_CONVERSION_SLOT;
fndecls = VEC_index (tree, methods, ix);
while (fndecls)
{
fndecl = OVL_CURRENT (fndecls);
fndecls = OVL_NEXT (fndecls);
if (!fndecls && is_conv_op)
{
if (VEC_length (tree, methods) > (size_t) ++ix)
{
fndecls = VEC_index (tree, methods, ix);
if (!DECL_CONV_FN_P (OVL_CURRENT (fndecls)))
{
fndecls = NULL_TREE;
is_conv_op = false;
}
}
else
is_conv_op = false;
}
if (format)
format = " %+#D";
else if (fndecls)
format = N_("candidates are: %+#D");
else
format = N_("candidate is: %+#D");
error (format, fndecl);
}
}
else if (!COMPLETE_TYPE_P (ctype))
cxx_incomplete_type_error (function, ctype);
else
error ("no %q#D member function declared in class %qT",
function, ctype);
if (pushed_scope)
pop_scope (pushed_scope);
return error_mark_node;
} | [
"tree",
"check_classfn",
"(",
"tree",
"ctype",
",",
"tree",
"function",
",",
"tree",
"template_parms",
")",
"{",
"int",
"ix",
";",
"bool",
"is_template",
";",
"tree",
"pushed_scope",
";",
"if",
"(",
"DECL_USE_TEMPLATE",
"(",
"function",
")",
"&&",
"!",
"(",
"TREE_CODE",
"(",
"function",
")",
"==",
"TEMPLATE_DECL",
"&&",
"DECL_TEMPLATE_SPECIALIZATION",
"(",
"function",
")",
")",
"&&",
"DECL_MEMBER_TEMPLATE_P",
"(",
"DECL_TI_TEMPLATE",
"(",
"function",
")",
")",
")",
"return",
"NULL_TREE",
";",
"if",
"(",
"TREE_CODE",
"(",
"function",
")",
"==",
"TEMPLATE_DECL",
")",
"{",
"if",
"(",
"template_parms",
"&&",
"!",
"comp_template_parms",
"(",
"template_parms",
",",
"DECL_TEMPLATE_PARMS",
"(",
"function",
")",
")",
")",
"{",
"error",
"(",
"\"",
"\"",
"\"",
"\"",
",",
"function",
")",
";",
"return",
"error_mark_node",
";",
"}",
"template_parms",
"=",
"DECL_TEMPLATE_PARMS",
"(",
"function",
")",
";",
"}",
"is_template",
"=",
"(",
"template_parms",
"!=",
"NULL_TREE",
")",
";",
"pushed_scope",
"=",
"push_scope",
"(",
"ctype",
")",
";",
"ix",
"=",
"class_method_index_for_fn",
"(",
"complete_type",
"(",
"ctype",
")",
",",
"function",
")",
";",
"if",
"(",
"ix",
">=",
"0",
")",
"{",
"VEC",
"(",
"tree",
",",
"gc",
")",
"*",
"methods",
"=",
"CLASSTYPE_METHOD_VEC",
"(",
"ctype",
")",
";",
"tree",
"fndecls",
",",
"fndecl",
"=",
"0",
";",
"bool",
"is_conv_op",
";",
"const",
"char",
"*",
"format",
"=",
"NULL",
";",
"for",
"(",
"fndecls",
"=",
"VEC_index",
"(",
"tree",
",",
"methods",
",",
"ix",
")",
";",
"fndecls",
";",
"fndecls",
"=",
"OVL_NEXT",
"(",
"fndecls",
")",
")",
"{",
"tree",
"p1",
",",
"p2",
";",
"fndecl",
"=",
"OVL_CURRENT",
"(",
"fndecls",
")",
";",
"p1",
"=",
"TYPE_ARG_TYPES",
"(",
"TREE_TYPE",
"(",
"function",
")",
")",
";",
"p2",
"=",
"TYPE_ARG_TYPES",
"(",
"TREE_TYPE",
"(",
"fndecl",
")",
")",
";",
"if",
"(",
"DECL_STATIC_FUNCTION_P",
"(",
"fndecl",
")",
"&&",
"TREE_CODE",
"(",
"TREE_TYPE",
"(",
"function",
")",
")",
"==",
"METHOD_TYPE",
")",
"p1",
"=",
"TREE_CHAIN",
"(",
"p1",
")",
";",
"if",
"(",
"is_template",
"!=",
"(",
"TREE_CODE",
"(",
"fndecl",
")",
"==",
"TEMPLATE_DECL",
")",
")",
"continue",
";",
"if",
"(",
"same_type_p",
"(",
"TREE_TYPE",
"(",
"TREE_TYPE",
"(",
"function",
")",
")",
",",
"TREE_TYPE",
"(",
"TREE_TYPE",
"(",
"fndecl",
")",
")",
")",
"&&",
"compparms",
"(",
"p1",
",",
"p2",
")",
"&&",
"(",
"!",
"is_template",
"||",
"comp_template_parms",
"(",
"template_parms",
",",
"DECL_TEMPLATE_PARMS",
"(",
"fndecl",
")",
")",
")",
"&&",
"(",
"DECL_TEMPLATE_SPECIALIZATION",
"(",
"function",
")",
"==",
"DECL_TEMPLATE_SPECIALIZATION",
"(",
"fndecl",
")",
")",
"&&",
"(",
"!",
"DECL_TEMPLATE_SPECIALIZATION",
"(",
"function",
")",
"||",
"(",
"DECL_TI_TEMPLATE",
"(",
"function",
")",
"==",
"DECL_TI_TEMPLATE",
"(",
"fndecl",
")",
")",
")",
")",
"break",
";",
"}",
"if",
"(",
"fndecls",
")",
"{",
"if",
"(",
"pushed_scope",
")",
"pop_scope",
"(",
"pushed_scope",
")",
";",
"return",
"OVL_CURRENT",
"(",
"fndecls",
")",
";",
"}",
"error_at",
"(",
"DECL_SOURCE_LOCATION",
"(",
"function",
")",
",",
"\"",
"\"",
",",
"function",
",",
"ctype",
")",
";",
"is_conv_op",
"=",
"DECL_CONV_FN_P",
"(",
"fndecl",
")",
";",
"if",
"(",
"is_conv_op",
")",
"ix",
"=",
"CLASSTYPE_FIRST_CONVERSION_SLOT",
";",
"fndecls",
"=",
"VEC_index",
"(",
"tree",
",",
"methods",
",",
"ix",
")",
";",
"while",
"(",
"fndecls",
")",
"{",
"fndecl",
"=",
"OVL_CURRENT",
"(",
"fndecls",
")",
";",
"fndecls",
"=",
"OVL_NEXT",
"(",
"fndecls",
")",
";",
"if",
"(",
"!",
"fndecls",
"&&",
"is_conv_op",
")",
"{",
"if",
"(",
"VEC_length",
"(",
"tree",
",",
"methods",
")",
">",
"(",
"size_t",
")",
"++",
"ix",
")",
"{",
"fndecls",
"=",
"VEC_index",
"(",
"tree",
",",
"methods",
",",
"ix",
")",
";",
"if",
"(",
"!",
"DECL_CONV_FN_P",
"(",
"OVL_CURRENT",
"(",
"fndecls",
")",
")",
")",
"{",
"fndecls",
"=",
"NULL_TREE",
";",
"is_conv_op",
"=",
"false",
";",
"}",
"}",
"else",
"is_conv_op",
"=",
"false",
";",
"}",
"if",
"(",
"format",
")",
"format",
"=",
"\"",
"\"",
";",
"else",
"if",
"(",
"fndecls",
")",
"format",
"=",
"N_",
"(",
"\"",
"\"",
")",
";",
"else",
"format",
"=",
"N_",
"(",
"\"",
"\"",
")",
";",
"error",
"(",
"format",
",",
"fndecl",
")",
";",
"}",
"}",
"else",
"if",
"(",
"!",
"COMPLETE_TYPE_P",
"(",
"ctype",
")",
")",
"cxx_incomplete_type_error",
"(",
"function",
",",
"ctype",
")",
";",
"else",
"error",
"(",
"\"",
"\"",
",",
"function",
",",
"ctype",
")",
";",
"if",
"(",
"pushed_scope",
")",
"pop_scope",
"(",
"pushed_scope",
")",
";",
"return",
"error_mark_node",
";",
"}"
] | Sanity check: report error if this function FUNCTION is not
really a member of the class (CTYPE) it is supposed to belong to. | [
"Sanity",
"check",
":",
"report",
"error",
"if",
"this",
"function",
"FUNCTION",
"is",
"not",
"really",
"a",
"member",
"of",
"the",
"class",
"(",
"CTYPE",
")",
"it",
"is",
"supposed",
"to",
"belong",
"to",
"."
] | [
"/* Since this is a specialization of a member template,\n we're not going to find the declaration in the class.\n For example, in:\n\n\t struct S { template <typename T> void f(T); };\n\t template <> void S::f(int);\n\n we're not going to find `S::f(int)', but there's no\n reason we should, either. We let our callers know we didn't\n find the method, but we don't complain. */",
"/* Basic sanity check: for a template function, the template parameters\n either were not passed, or they are the same of DECL_TEMPLATE_PARMS. */",
"/* OK, is this a definition of a member template? */",
"/* We must enter the scope here, because conversion operators are\n named by target type, and type equivalence relies on typenames\n resolving within the scope of CTYPE. */",
"/* We cannot simply call decls_match because this doesn't\n\t work for static member functions that are pretending to\n\t be methods, and because the name may have been changed by\n\t asm(\"new_name\"). */",
"/* Get rid of the this parameter on functions that become\n\t static. */",
"/* A member template definition only matches a member template\n\t declaration. */"
] | [
{
"param": "ctype",
"type": "tree"
},
{
"param": "function",
"type": "tree"
},
{
"param": "template_parms",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "ctype",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "function",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "template_parms",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | note_vague_linkage_fn | void | void
note_vague_linkage_fn (tree decl)
{
DECL_DEFER_OUTPUT (decl) = 1;
VEC_safe_push (tree, gc, deferred_fns, decl);
} | /* DECL is a function with vague linkage. Remember it so that at the
end of the translation unit we can decide whether or not to emit
it. */ | DECL is a function with vague linkage. Remember it so that at the
end of the translation unit we can decide whether or not to emit
it. | [
"DECL",
"is",
"a",
"function",
"with",
"vague",
"linkage",
".",
"Remember",
"it",
"so",
"that",
"at",
"the",
"end",
"of",
"the",
"translation",
"unit",
"we",
"can",
"decide",
"whether",
"or",
"not",
"to",
"emit",
"it",
"."
] | void
note_vague_linkage_fn (tree decl)
{
DECL_DEFER_OUTPUT (decl) = 1;
VEC_safe_push (tree, gc, deferred_fns, decl);
} | [
"void",
"note_vague_linkage_fn",
"(",
"tree",
"decl",
")",
"{",
"DECL_DEFER_OUTPUT",
"(",
"decl",
")",
"=",
"1",
";",
"VEC_safe_push",
"(",
"tree",
",",
"gc",
",",
"deferred_fns",
",",
"decl",
")",
";",
"}"
] | DECL is a function with vague linkage. | [
"DECL",
"is",
"a",
"function",
"with",
"vague",
"linkage",
"."
] | [] | [
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | finish_static_data_member_decl | void | void
finish_static_data_member_decl (tree decl,
tree init, bool init_const_expr_p,
tree asmspec_tree,
int flags)
{
DECL_CONTEXT (decl) = current_class_type;
/* We cannot call pushdecl here, because that would fill in the
TREE_CHAIN of our decl. Instead, we modify cp_finish_decl to do
the right thing, namely, to put this decl out straight away. */
if (! processing_template_decl)
VEC_safe_push (tree, gc, pending_statics, decl);
if (LOCAL_CLASS_P (current_class_type))
permerror (input_location, "local class %q#T shall not have static data member %q#D",
current_class_type, decl);
DECL_IN_AGGR_P (decl) = 1;
if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
&& TYPE_DOMAIN (TREE_TYPE (decl)) == NULL_TREE)
SET_VAR_HAD_UNKNOWN_BOUND (decl);
cp_finish_decl (decl, init, init_const_expr_p, asmspec_tree, flags);
} | /* We have just processed the DECL, which is a static data member.
The other parameters are as for cp_finish_decl. */ | We have just processed the DECL, which is a static data member.
The other parameters are as for cp_finish_decl. | [
"We",
"have",
"just",
"processed",
"the",
"DECL",
"which",
"is",
"a",
"static",
"data",
"member",
".",
"The",
"other",
"parameters",
"are",
"as",
"for",
"cp_finish_decl",
"."
] | void
finish_static_data_member_decl (tree decl,
tree init, bool init_const_expr_p,
tree asmspec_tree,
int flags)
{
DECL_CONTEXT (decl) = current_class_type;
if (! processing_template_decl)
VEC_safe_push (tree, gc, pending_statics, decl);
if (LOCAL_CLASS_P (current_class_type))
permerror (input_location, "local class %q#T shall not have static data member %q#D",
current_class_type, decl);
DECL_IN_AGGR_P (decl) = 1;
if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
&& TYPE_DOMAIN (TREE_TYPE (decl)) == NULL_TREE)
SET_VAR_HAD_UNKNOWN_BOUND (decl);
cp_finish_decl (decl, init, init_const_expr_p, asmspec_tree, flags);
} | [
"void",
"finish_static_data_member_decl",
"(",
"tree",
"decl",
",",
"tree",
"init",
",",
"bool",
"init_const_expr_p",
",",
"tree",
"asmspec_tree",
",",
"int",
"flags",
")",
"{",
"DECL_CONTEXT",
"(",
"decl",
")",
"=",
"current_class_type",
";",
"if",
"(",
"!",
"processing_template_decl",
")",
"VEC_safe_push",
"(",
"tree",
",",
"gc",
",",
"pending_statics",
",",
"decl",
")",
";",
"if",
"(",
"LOCAL_CLASS_P",
"(",
"current_class_type",
")",
")",
"permerror",
"(",
"input_location",
",",
"\"",
"\"",
",",
"current_class_type",
",",
"decl",
")",
";",
"DECL_IN_AGGR_P",
"(",
"decl",
")",
"=",
"1",
";",
"if",
"(",
"TREE_CODE",
"(",
"TREE_TYPE",
"(",
"decl",
")",
")",
"==",
"ARRAY_TYPE",
"&&",
"TYPE_DOMAIN",
"(",
"TREE_TYPE",
"(",
"decl",
")",
")",
"==",
"NULL_TREE",
")",
"SET_VAR_HAD_UNKNOWN_BOUND",
"(",
"decl",
")",
";",
"cp_finish_decl",
"(",
"decl",
",",
"init",
",",
"init_const_expr_p",
",",
"asmspec_tree",
",",
"flags",
")",
";",
"}"
] | We have just processed the DECL, which is a static data member. | [
"We",
"have",
"just",
"processed",
"the",
"DECL",
"which",
"is",
"a",
"static",
"data",
"member",
"."
] | [
"/* We cannot call pushdecl here, because that would fill in the\n TREE_CHAIN of our decl. Instead, we modify cp_finish_decl to do\n the right thing, namely, to put this decl out straight away. */"
] | [
{
"param": "decl",
"type": "tree"
},
{
"param": "init",
"type": "tree"
},
{
"param": "init_const_expr_p",
"type": "bool"
},
{
"param": "asmspec_tree",
"type": "tree"
},
{
"param": "flags",
"type": "int"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "init",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "init_const_expr_p",
"type": "bool",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "asmspec_tree",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "flags",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | grokfield | tree | tree
grokfield (const cp_declarator *declarator,
cp_decl_specifier_seq *declspecs,
tree init, bool init_const_expr_p,
tree asmspec_tree,
tree attrlist)
{
tree value;
const char *asmspec = 0;
int flags;
tree name;
if (init
&& TREE_CODE (init) == TREE_LIST
&& TREE_VALUE (init) == error_mark_node
&& TREE_CHAIN (init) == NULL_TREE)
init = NULL_TREE;
value = grokdeclarator (declarator, declspecs, FIELD, init != 0, &attrlist);
if (! value || error_operand_p (value))
/* friend or constructor went bad. */
return error_mark_node;
if (TREE_CODE (value) == TYPE_DECL && init)
{
error ("typedef %qD is initialized (use decltype instead)", value);
init = NULL_TREE;
}
/* Pass friendly classes back. */
if (value == void_type_node)
return value;
/* Pass friend decls back. */
if ((TREE_CODE (value) == FUNCTION_DECL
|| TREE_CODE (value) == TEMPLATE_DECL)
&& DECL_CONTEXT (value) != current_class_type)
return value;
name = DECL_NAME (value);
if (name != NULL_TREE)
{
if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
{
error ("explicit template argument list not allowed");
return error_mark_node;
}
if (IDENTIFIER_POINTER (name)[0] == '_'
&& ! strcmp (IDENTIFIER_POINTER (name), "_vptr"))
error ("member %qD conflicts with virtual function table field name",
value);
}
/* Stash away type declarations. */
if (TREE_CODE (value) == TYPE_DECL)
{
DECL_NONLOCAL (value) = 1;
DECL_CONTEXT (value) = current_class_type;
if (attrlist)
{
int attrflags = 0;
/* If this is a typedef that names the class for linkage purposes
(7.1.3p8), apply any attributes directly to the type. */
if (TAGGED_TYPE_P (TREE_TYPE (value))
&& value == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value))))
attrflags = ATTR_FLAG_TYPE_IN_PLACE;
cplus_decl_attributes (&value, attrlist, attrflags);
}
if (declspecs->specs[(int)ds_typedef]
&& TREE_TYPE (value) != error_mark_node
&& TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value))) != value)
set_underlying_type (value);
/* It's important that push_template_decl below follows
set_underlying_type above so that the created template
carries the properly set type of VALUE. */
if (processing_template_decl)
value = push_template_decl (value);
record_locally_defined_typedef (value);
return value;
}
if (DECL_IN_AGGR_P (value))
{
error ("%qD is already defined in %qT", value, DECL_CONTEXT (value));
return void_type_node;
}
if (asmspec_tree && asmspec_tree != error_mark_node)
asmspec = TREE_STRING_POINTER (asmspec_tree);
if (init)
{
if (TREE_CODE (value) == FUNCTION_DECL)
{
/* Initializers for functions are rejected early in the parser.
If we get here, it must be a pure specifier for a method. */
if (init == ridpointers[(int)RID_DELETE])
{
DECL_DELETED_FN (value) = 1;
DECL_DECLARED_INLINE_P (value) = 1;
DECL_INITIAL (value) = error_mark_node;
}
else if (init == ridpointers[(int)RID_DEFAULT])
{
if (defaultable_fn_check (value))
{
DECL_DEFAULTED_FN (value) = 1;
DECL_INITIALIZED_IN_CLASS_P (value) = 1;
DECL_DECLARED_INLINE_P (value) = 1;
}
}
else if (TREE_CODE (init) == DEFAULT_ARG)
error ("invalid initializer for member function %qD", value);
else if (TREE_CODE (TREE_TYPE (value)) == METHOD_TYPE)
{
if (integer_zerop (init))
DECL_PURE_VIRTUAL_P (value) = 1;
else if (error_operand_p (init))
; /* An error has already been reported. */
else
error ("invalid initializer for member function %qD",
value);
}
else
{
gcc_assert (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE);
error ("initializer specified for static member function %qD",
value);
}
}
else if (TREE_CODE (value) == FIELD_DECL)
/* C++11 NSDMI, keep going. */;
else if (TREE_CODE (value) != VAR_DECL)
gcc_unreachable ();
else if (!processing_template_decl)
{
if (TREE_CODE (init) == CONSTRUCTOR)
init = digest_init (TREE_TYPE (value), init, tf_warning_or_error);
init = maybe_constant_init (init);
if (init != error_mark_node && !TREE_CONSTANT (init))
{
/* We can allow references to things that are effectively
static, since references are initialized with the
address. */
if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE
|| (TREE_STATIC (init) == 0
&& (!DECL_P (init) || DECL_EXTERNAL (init) == 0)))
{
error ("field initializer is not constant");
init = error_mark_node;
}
}
}
}
if (processing_template_decl
&& (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == FUNCTION_DECL))
{
value = push_template_decl (value);
if (error_operand_p (value))
return error_mark_node;
}
if (attrlist)
cplus_decl_attributes (&value, attrlist, 0);
if (init && BRACE_ENCLOSED_INITIALIZER_P (init)
&& CONSTRUCTOR_IS_DIRECT_INIT (init))
flags = LOOKUP_NORMAL;
else
flags = LOOKUP_IMPLICIT;
switch (TREE_CODE (value))
{
case VAR_DECL:
finish_static_data_member_decl (value, init, init_const_expr_p,
asmspec_tree, flags);
return value;
case FIELD_DECL:
if (asmspec)
error ("%<asm%> specifiers are not permitted on non-static data members");
if (DECL_INITIAL (value) == error_mark_node)
init = error_mark_node;
cp_finish_decl (value, init, /*init_const_expr_p=*/false,
NULL_TREE, flags);
DECL_IN_AGGR_P (value) = 1;
return value;
case FUNCTION_DECL:
if (asmspec)
set_user_assembler_name (value, asmspec);
cp_finish_decl (value,
/*init=*/NULL_TREE,
/*init_const_expr_p=*/false,
asmspec_tree, flags);
/* Pass friends back this way. */
if (DECL_FRIEND_P (value))
return void_type_node;
DECL_IN_AGGR_P (value) = 1;
return value;
default:
gcc_unreachable ();
}
return NULL_TREE;
} | /* DECLARATOR and DECLSPECS correspond to a class member. The other
parameters are as for cp_finish_decl. Return the DECL for the
class member declared. */ | DECLARATOR and DECLSPECS correspond to a class member. The other
parameters are as for cp_finish_decl. Return the DECL for the
class member declared. | [
"DECLARATOR",
"and",
"DECLSPECS",
"correspond",
"to",
"a",
"class",
"member",
".",
"The",
"other",
"parameters",
"are",
"as",
"for",
"cp_finish_decl",
".",
"Return",
"the",
"DECL",
"for",
"the",
"class",
"member",
"declared",
"."
] | tree
grokfield (const cp_declarator *declarator,
cp_decl_specifier_seq *declspecs,
tree init, bool init_const_expr_p,
tree asmspec_tree,
tree attrlist)
{
tree value;
const char *asmspec = 0;
int flags;
tree name;
if (init
&& TREE_CODE (init) == TREE_LIST
&& TREE_VALUE (init) == error_mark_node
&& TREE_CHAIN (init) == NULL_TREE)
init = NULL_TREE;
value = grokdeclarator (declarator, declspecs, FIELD, init != 0, &attrlist);
if (! value || error_operand_p (value))
return error_mark_node;
if (TREE_CODE (value) == TYPE_DECL && init)
{
error ("typedef %qD is initialized (use decltype instead)", value);
init = NULL_TREE;
}
if (value == void_type_node)
return value;
if ((TREE_CODE (value) == FUNCTION_DECL
|| TREE_CODE (value) == TEMPLATE_DECL)
&& DECL_CONTEXT (value) != current_class_type)
return value;
name = DECL_NAME (value);
if (name != NULL_TREE)
{
if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
{
error ("explicit template argument list not allowed");
return error_mark_node;
}
if (IDENTIFIER_POINTER (name)[0] == '_'
&& ! strcmp (IDENTIFIER_POINTER (name), "_vptr"))
error ("member %qD conflicts with virtual function table field name",
value);
}
if (TREE_CODE (value) == TYPE_DECL)
{
DECL_NONLOCAL (value) = 1;
DECL_CONTEXT (value) = current_class_type;
if (attrlist)
{
int attrflags = 0;
if (TAGGED_TYPE_P (TREE_TYPE (value))
&& value == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value))))
attrflags = ATTR_FLAG_TYPE_IN_PLACE;
cplus_decl_attributes (&value, attrlist, attrflags);
}
if (declspecs->specs[(int)ds_typedef]
&& TREE_TYPE (value) != error_mark_node
&& TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value))) != value)
set_underlying_type (value);
if (processing_template_decl)
value = push_template_decl (value);
record_locally_defined_typedef (value);
return value;
}
if (DECL_IN_AGGR_P (value))
{
error ("%qD is already defined in %qT", value, DECL_CONTEXT (value));
return void_type_node;
}
if (asmspec_tree && asmspec_tree != error_mark_node)
asmspec = TREE_STRING_POINTER (asmspec_tree);
if (init)
{
if (TREE_CODE (value) == FUNCTION_DECL)
{
if (init == ridpointers[(int)RID_DELETE])
{
DECL_DELETED_FN (value) = 1;
DECL_DECLARED_INLINE_P (value) = 1;
DECL_INITIAL (value) = error_mark_node;
}
else if (init == ridpointers[(int)RID_DEFAULT])
{
if (defaultable_fn_check (value))
{
DECL_DEFAULTED_FN (value) = 1;
DECL_INITIALIZED_IN_CLASS_P (value) = 1;
DECL_DECLARED_INLINE_P (value) = 1;
}
}
else if (TREE_CODE (init) == DEFAULT_ARG)
error ("invalid initializer for member function %qD", value);
else if (TREE_CODE (TREE_TYPE (value)) == METHOD_TYPE)
{
if (integer_zerop (init))
DECL_PURE_VIRTUAL_P (value) = 1;
else if (error_operand_p (init))
;
else
error ("invalid initializer for member function %qD",
value);
}
else
{
gcc_assert (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE);
error ("initializer specified for static member function %qD",
value);
}
}
else if (TREE_CODE (value) == FIELD_DECL)
;
else if (TREE_CODE (value) != VAR_DECL)
gcc_unreachable ();
else if (!processing_template_decl)
{
if (TREE_CODE (init) == CONSTRUCTOR)
init = digest_init (TREE_TYPE (value), init, tf_warning_or_error);
init = maybe_constant_init (init);
if (init != error_mark_node && !TREE_CONSTANT (init))
{
if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE
|| (TREE_STATIC (init) == 0
&& (!DECL_P (init) || DECL_EXTERNAL (init) == 0)))
{
error ("field initializer is not constant");
init = error_mark_node;
}
}
}
}
if (processing_template_decl
&& (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == FUNCTION_DECL))
{
value = push_template_decl (value);
if (error_operand_p (value))
return error_mark_node;
}
if (attrlist)
cplus_decl_attributes (&value, attrlist, 0);
if (init && BRACE_ENCLOSED_INITIALIZER_P (init)
&& CONSTRUCTOR_IS_DIRECT_INIT (init))
flags = LOOKUP_NORMAL;
else
flags = LOOKUP_IMPLICIT;
switch (TREE_CODE (value))
{
case VAR_DECL:
finish_static_data_member_decl (value, init, init_const_expr_p,
asmspec_tree, flags);
return value;
case FIELD_DECL:
if (asmspec)
error ("%<asm%> specifiers are not permitted on non-static data members");
if (DECL_INITIAL (value) == error_mark_node)
init = error_mark_node;
cp_finish_decl (value, init, false,
NULL_TREE, flags);
DECL_IN_AGGR_P (value) = 1;
return value;
case FUNCTION_DECL:
if (asmspec)
set_user_assembler_name (value, asmspec);
cp_finish_decl (value,
NULL_TREE,
false,
asmspec_tree, flags);
if (DECL_FRIEND_P (value))
return void_type_node;
DECL_IN_AGGR_P (value) = 1;
return value;
default:
gcc_unreachable ();
}
return NULL_TREE;
} | [
"tree",
"grokfield",
"(",
"const",
"cp_declarator",
"*",
"declarator",
",",
"cp_decl_specifier_seq",
"*",
"declspecs",
",",
"tree",
"init",
",",
"bool",
"init_const_expr_p",
",",
"tree",
"asmspec_tree",
",",
"tree",
"attrlist",
")",
"{",
"tree",
"value",
";",
"const",
"char",
"*",
"asmspec",
"=",
"0",
";",
"int",
"flags",
";",
"tree",
"name",
";",
"if",
"(",
"init",
"&&",
"TREE_CODE",
"(",
"init",
")",
"==",
"TREE_LIST",
"&&",
"TREE_VALUE",
"(",
"init",
")",
"==",
"error_mark_node",
"&&",
"TREE_CHAIN",
"(",
"init",
")",
"==",
"NULL_TREE",
")",
"init",
"=",
"NULL_TREE",
";",
"value",
"=",
"grokdeclarator",
"(",
"declarator",
",",
"declspecs",
",",
"FIELD",
",",
"init",
"!=",
"0",
",",
"&",
"attrlist",
")",
";",
"if",
"(",
"!",
"value",
"||",
"error_operand_p",
"(",
"value",
")",
")",
"return",
"error_mark_node",
";",
"if",
"(",
"TREE_CODE",
"(",
"value",
")",
"==",
"TYPE_DECL",
"&&",
"init",
")",
"{",
"error",
"(",
"\"",
"\"",
",",
"value",
")",
";",
"init",
"=",
"NULL_TREE",
";",
"}",
"if",
"(",
"value",
"==",
"void_type_node",
")",
"return",
"value",
";",
"if",
"(",
"(",
"TREE_CODE",
"(",
"value",
")",
"==",
"FUNCTION_DECL",
"||",
"TREE_CODE",
"(",
"value",
")",
"==",
"TEMPLATE_DECL",
")",
"&&",
"DECL_CONTEXT",
"(",
"value",
")",
"!=",
"current_class_type",
")",
"return",
"value",
";",
"name",
"=",
"DECL_NAME",
"(",
"value",
")",
";",
"if",
"(",
"name",
"!=",
"NULL_TREE",
")",
"{",
"if",
"(",
"TREE_CODE",
"(",
"name",
")",
"==",
"TEMPLATE_ID_EXPR",
")",
"{",
"error",
"(",
"\"",
"\"",
")",
";",
"return",
"error_mark_node",
";",
"}",
"if",
"(",
"IDENTIFIER_POINTER",
"(",
"name",
")",
"[",
"0",
"]",
"==",
"'",
"'",
"&&",
"!",
"strcmp",
"(",
"IDENTIFIER_POINTER",
"(",
"name",
")",
",",
"\"",
"\"",
")",
")",
"error",
"(",
"\"",
"\"",
",",
"value",
")",
";",
"}",
"if",
"(",
"TREE_CODE",
"(",
"value",
")",
"==",
"TYPE_DECL",
")",
"{",
"DECL_NONLOCAL",
"(",
"value",
")",
"=",
"1",
";",
"DECL_CONTEXT",
"(",
"value",
")",
"=",
"current_class_type",
";",
"if",
"(",
"attrlist",
")",
"{",
"int",
"attrflags",
"=",
"0",
";",
"if",
"(",
"TAGGED_TYPE_P",
"(",
"TREE_TYPE",
"(",
"value",
")",
")",
"&&",
"value",
"==",
"TYPE_NAME",
"(",
"TYPE_MAIN_VARIANT",
"(",
"TREE_TYPE",
"(",
"value",
")",
")",
")",
")",
"attrflags",
"=",
"ATTR_FLAG_TYPE_IN_PLACE",
";",
"cplus_decl_attributes",
"(",
"&",
"value",
",",
"attrlist",
",",
"attrflags",
")",
";",
"}",
"if",
"(",
"declspecs",
"->",
"specs",
"[",
"(",
"int",
")",
"ds_typedef",
"]",
"&&",
"TREE_TYPE",
"(",
"value",
")",
"!=",
"error_mark_node",
"&&",
"TYPE_NAME",
"(",
"TYPE_MAIN_VARIANT",
"(",
"TREE_TYPE",
"(",
"value",
")",
")",
")",
"!=",
"value",
")",
"set_underlying_type",
"(",
"value",
")",
";",
"if",
"(",
"processing_template_decl",
")",
"value",
"=",
"push_template_decl",
"(",
"value",
")",
";",
"record_locally_defined_typedef",
"(",
"value",
")",
";",
"return",
"value",
";",
"}",
"if",
"(",
"DECL_IN_AGGR_P",
"(",
"value",
")",
")",
"{",
"error",
"(",
"\"",
"\"",
",",
"value",
",",
"DECL_CONTEXT",
"(",
"value",
")",
")",
";",
"return",
"void_type_node",
";",
"}",
"if",
"(",
"asmspec_tree",
"&&",
"asmspec_tree",
"!=",
"error_mark_node",
")",
"asmspec",
"=",
"TREE_STRING_POINTER",
"(",
"asmspec_tree",
")",
";",
"if",
"(",
"init",
")",
"{",
"if",
"(",
"TREE_CODE",
"(",
"value",
")",
"==",
"FUNCTION_DECL",
")",
"{",
"if",
"(",
"init",
"==",
"ridpointers",
"[",
"(",
"int",
")",
"RID_DELETE",
"]",
")",
"{",
"DECL_DELETED_FN",
"(",
"value",
")",
"=",
"1",
";",
"DECL_DECLARED_INLINE_P",
"(",
"value",
")",
"=",
"1",
";",
"DECL_INITIAL",
"(",
"value",
")",
"=",
"error_mark_node",
";",
"}",
"else",
"if",
"(",
"init",
"==",
"ridpointers",
"[",
"(",
"int",
")",
"RID_DEFAULT",
"]",
")",
"{",
"if",
"(",
"defaultable_fn_check",
"(",
"value",
")",
")",
"{",
"DECL_DEFAULTED_FN",
"(",
"value",
")",
"=",
"1",
";",
"DECL_INITIALIZED_IN_CLASS_P",
"(",
"value",
")",
"=",
"1",
";",
"DECL_DECLARED_INLINE_P",
"(",
"value",
")",
"=",
"1",
";",
"}",
"}",
"else",
"if",
"(",
"TREE_CODE",
"(",
"init",
")",
"==",
"DEFAULT_ARG",
")",
"error",
"(",
"\"",
"\"",
",",
"value",
")",
";",
"else",
"if",
"(",
"TREE_CODE",
"(",
"TREE_TYPE",
"(",
"value",
")",
")",
"==",
"METHOD_TYPE",
")",
"{",
"if",
"(",
"integer_zerop",
"(",
"init",
")",
")",
"DECL_PURE_VIRTUAL_P",
"(",
"value",
")",
"=",
"1",
";",
"else",
"if",
"(",
"error_operand_p",
"(",
"init",
")",
")",
";",
"else",
"error",
"(",
"\"",
"\"",
",",
"value",
")",
";",
"}",
"else",
"{",
"gcc_assert",
"(",
"TREE_CODE",
"(",
"TREE_TYPE",
"(",
"value",
")",
")",
"==",
"FUNCTION_TYPE",
")",
";",
"error",
"(",
"\"",
"\"",
",",
"value",
")",
";",
"}",
"}",
"else",
"if",
"(",
"TREE_CODE",
"(",
"value",
")",
"==",
"FIELD_DECL",
")",
";",
"else",
"if",
"(",
"TREE_CODE",
"(",
"value",
")",
"!=",
"VAR_DECL",
")",
"gcc_unreachable",
"(",
")",
";",
"else",
"if",
"(",
"!",
"processing_template_decl",
")",
"{",
"if",
"(",
"TREE_CODE",
"(",
"init",
")",
"==",
"CONSTRUCTOR",
")",
"init",
"=",
"digest_init",
"(",
"TREE_TYPE",
"(",
"value",
")",
",",
"init",
",",
"tf_warning_or_error",
")",
";",
"init",
"=",
"maybe_constant_init",
"(",
"init",
")",
";",
"if",
"(",
"init",
"!=",
"error_mark_node",
"&&",
"!",
"TREE_CONSTANT",
"(",
"init",
")",
")",
"{",
"if",
"(",
"TREE_CODE",
"(",
"TREE_TYPE",
"(",
"value",
")",
")",
"!=",
"REFERENCE_TYPE",
"||",
"(",
"TREE_STATIC",
"(",
"init",
")",
"==",
"0",
"&&",
"(",
"!",
"DECL_P",
"(",
"init",
")",
"||",
"DECL_EXTERNAL",
"(",
"init",
")",
"==",
"0",
")",
")",
")",
"{",
"error",
"(",
"\"",
"\"",
")",
";",
"init",
"=",
"error_mark_node",
";",
"}",
"}",
"}",
"}",
"if",
"(",
"processing_template_decl",
"&&",
"(",
"TREE_CODE",
"(",
"value",
")",
"==",
"VAR_DECL",
"||",
"TREE_CODE",
"(",
"value",
")",
"==",
"FUNCTION_DECL",
")",
")",
"{",
"value",
"=",
"push_template_decl",
"(",
"value",
")",
";",
"if",
"(",
"error_operand_p",
"(",
"value",
")",
")",
"return",
"error_mark_node",
";",
"}",
"if",
"(",
"attrlist",
")",
"cplus_decl_attributes",
"(",
"&",
"value",
",",
"attrlist",
",",
"0",
")",
";",
"if",
"(",
"init",
"&&",
"BRACE_ENCLOSED_INITIALIZER_P",
"(",
"init",
")",
"&&",
"CONSTRUCTOR_IS_DIRECT_INIT",
"(",
"init",
")",
")",
"flags",
"=",
"LOOKUP_NORMAL",
";",
"else",
"flags",
"=",
"LOOKUP_IMPLICIT",
";",
"switch",
"(",
"TREE_CODE",
"(",
"value",
")",
")",
"{",
"case",
"VAR_DECL",
":",
"finish_static_data_member_decl",
"(",
"value",
",",
"init",
",",
"init_const_expr_p",
",",
"asmspec_tree",
",",
"flags",
")",
";",
"return",
"value",
";",
"case",
"FIELD_DECL",
":",
"if",
"(",
"asmspec",
")",
"error",
"(",
"\"",
"\"",
")",
";",
"if",
"(",
"DECL_INITIAL",
"(",
"value",
")",
"==",
"error_mark_node",
")",
"init",
"=",
"error_mark_node",
";",
"cp_finish_decl",
"(",
"value",
",",
"init",
",",
"false",
",",
"NULL_TREE",
",",
"flags",
")",
";",
"DECL_IN_AGGR_P",
"(",
"value",
")",
"=",
"1",
";",
"return",
"value",
";",
"case",
"FUNCTION_DECL",
":",
"if",
"(",
"asmspec",
")",
"set_user_assembler_name",
"(",
"value",
",",
"asmspec",
")",
";",
"cp_finish_decl",
"(",
"value",
",",
"NULL_TREE",
",",
"false",
",",
"asmspec_tree",
",",
"flags",
")",
";",
"if",
"(",
"DECL_FRIEND_P",
"(",
"value",
")",
")",
"return",
"void_type_node",
";",
"DECL_IN_AGGR_P",
"(",
"value",
")",
"=",
"1",
";",
"return",
"value",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"NULL_TREE",
";",
"}"
] | DECLARATOR and DECLSPECS correspond to a class member. | [
"DECLARATOR",
"and",
"DECLSPECS",
"correspond",
"to",
"a",
"class",
"member",
"."
] | [
"/* friend or constructor went bad. */",
"/* Pass friendly classes back. */",
"/* Pass friend decls back. */",
"/* Stash away type declarations. */",
"/* If this is a typedef that names the class for linkage purposes\n\t (7.1.3p8), apply any attributes directly to the type. */",
"/* It's important that push_template_decl below follows\n\t set_underlying_type above so that the created template\n\t carries the properly set type of VALUE. */",
"/* Initializers for functions are rejected early in the parser.\n\t If we get here, it must be a pure specifier for a method. */",
"/* An error has already been reported. */",
"/* C++11 NSDMI, keep going. */",
"/* We can allow references to things that are effectively\n\t\t static, since references are initialized with the\n\t\t address. */",
"/*init_const_expr_p=*/",
"/*init=*/",
"/*init_const_expr_p=*/",
"/* Pass friends back this way. */"
] | [
{
"param": "declarator",
"type": "cp_declarator"
},
{
"param": "declspecs",
"type": "cp_decl_specifier_seq"
},
{
"param": "init",
"type": "tree"
},
{
"param": "init_const_expr_p",
"type": "bool"
},
{
"param": "asmspec_tree",
"type": "tree"
},
{
"param": "attrlist",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "declarator",
"type": "cp_declarator",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "declspecs",
"type": "cp_decl_specifier_seq",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "init",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "init_const_expr_p",
"type": "bool",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "asmspec_tree",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "attrlist",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | is_late_template_attribute | bool | static bool
is_late_template_attribute (tree attr, tree decl)
{
tree name = TREE_PURPOSE (attr);
tree args = TREE_VALUE (attr);
const struct attribute_spec *spec = lookup_attribute_spec (name);
tree arg;
if (!spec)
/* Unknown attribute. */
return false;
/* Attribute weak handling wants to write out assembly right away. */
if (is_attribute_p ("weak", name))
return true;
/* If any of the arguments are dependent expressions, we can't evaluate
the attribute until instantiation time. */
for (arg = args; arg; arg = TREE_CHAIN (arg))
{
tree t = TREE_VALUE (arg);
/* If the first attribute argument is an identifier, only consider
second and following arguments. Attributes like mode, format,
cleanup and several target specific attributes aren't late
just because they have an IDENTIFIER_NODE as first argument. */
if (arg == args && TREE_CODE (t) == IDENTIFIER_NODE)
continue;
if (value_dependent_expression_p (t)
|| type_dependent_expression_p (t))
return true;
}
if (TREE_CODE (decl) == TYPE_DECL
|| TYPE_P (decl)
|| spec->type_required)
{
tree type = TYPE_P (decl) ? decl : TREE_TYPE (decl);
/* We can't apply any attributes to a completely unknown type until
instantiation time. */
enum tree_code code = TREE_CODE (type);
if (code == TEMPLATE_TYPE_PARM
|| code == BOUND_TEMPLATE_TEMPLATE_PARM
|| code == TYPENAME_TYPE)
return true;
/* Also defer most attributes on dependent types. This is not
necessary in all cases, but is the better default. */
else if (dependent_type_p (type)
/* But attribute visibility specifically works on
templates. */
&& !is_attribute_p ("visibility", name))
return true;
else
return false;
}
else
return false;
} | /* Returns true iff ATTR is an attribute which needs to be applied at
instantiation time rather than template definition time. */ | Returns true iff ATTR is an attribute which needs to be applied at
instantiation time rather than template definition time. | [
"Returns",
"true",
"iff",
"ATTR",
"is",
"an",
"attribute",
"which",
"needs",
"to",
"be",
"applied",
"at",
"instantiation",
"time",
"rather",
"than",
"template",
"definition",
"time",
"."
] | static bool
is_late_template_attribute (tree attr, tree decl)
{
tree name = TREE_PURPOSE (attr);
tree args = TREE_VALUE (attr);
const struct attribute_spec *spec = lookup_attribute_spec (name);
tree arg;
if (!spec)
return false;
if (is_attribute_p ("weak", name))
return true;
for (arg = args; arg; arg = TREE_CHAIN (arg))
{
tree t = TREE_VALUE (arg);
if (arg == args && TREE_CODE (t) == IDENTIFIER_NODE)
continue;
if (value_dependent_expression_p (t)
|| type_dependent_expression_p (t))
return true;
}
if (TREE_CODE (decl) == TYPE_DECL
|| TYPE_P (decl)
|| spec->type_required)
{
tree type = TYPE_P (decl) ? decl : TREE_TYPE (decl);
enum tree_code code = TREE_CODE (type);
if (code == TEMPLATE_TYPE_PARM
|| code == BOUND_TEMPLATE_TEMPLATE_PARM
|| code == TYPENAME_TYPE)
return true;
else if (dependent_type_p (type)
&& !is_attribute_p ("visibility", name))
return true;
else
return false;
}
else
return false;
} | [
"static",
"bool",
"is_late_template_attribute",
"(",
"tree",
"attr",
",",
"tree",
"decl",
")",
"{",
"tree",
"name",
"=",
"TREE_PURPOSE",
"(",
"attr",
")",
";",
"tree",
"args",
"=",
"TREE_VALUE",
"(",
"attr",
")",
";",
"const",
"struct",
"attribute_spec",
"*",
"spec",
"=",
"lookup_attribute_spec",
"(",
"name",
")",
";",
"tree",
"arg",
";",
"if",
"(",
"!",
"spec",
")",
"return",
"false",
";",
"if",
"(",
"is_attribute_p",
"(",
"\"",
"\"",
",",
"name",
")",
")",
"return",
"true",
";",
"for",
"(",
"arg",
"=",
"args",
";",
"arg",
";",
"arg",
"=",
"TREE_CHAIN",
"(",
"arg",
")",
")",
"{",
"tree",
"t",
"=",
"TREE_VALUE",
"(",
"arg",
")",
";",
"if",
"(",
"arg",
"==",
"args",
"&&",
"TREE_CODE",
"(",
"t",
")",
"==",
"IDENTIFIER_NODE",
")",
"continue",
";",
"if",
"(",
"value_dependent_expression_p",
"(",
"t",
")",
"||",
"type_dependent_expression_p",
"(",
"t",
")",
")",
"return",
"true",
";",
"}",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"TYPE_DECL",
"||",
"TYPE_P",
"(",
"decl",
")",
"||",
"spec",
"->",
"type_required",
")",
"{",
"tree",
"type",
"=",
"TYPE_P",
"(",
"decl",
")",
"?",
"decl",
":",
"TREE_TYPE",
"(",
"decl",
")",
";",
"enum",
"tree_code",
"code",
"=",
"TREE_CODE",
"(",
"type",
")",
";",
"if",
"(",
"code",
"==",
"TEMPLATE_TYPE_PARM",
"||",
"code",
"==",
"BOUND_TEMPLATE_TEMPLATE_PARM",
"||",
"code",
"==",
"TYPENAME_TYPE",
")",
"return",
"true",
";",
"else",
"if",
"(",
"dependent_type_p",
"(",
"type",
")",
"&&",
"!",
"is_attribute_p",
"(",
"\"",
"\"",
",",
"name",
")",
")",
"return",
"true",
";",
"else",
"return",
"false",
";",
"}",
"else",
"return",
"false",
";",
"}"
] | Returns true iff ATTR is an attribute which needs to be applied at
instantiation time rather than template definition time. | [
"Returns",
"true",
"iff",
"ATTR",
"is",
"an",
"attribute",
"which",
"needs",
"to",
"be",
"applied",
"at",
"instantiation",
"time",
"rather",
"than",
"template",
"definition",
"time",
"."
] | [
"/* Unknown attribute. */",
"/* Attribute weak handling wants to write out assembly right away. */",
"/* If any of the arguments are dependent expressions, we can't evaluate\n the attribute until instantiation time. */",
"/* If the first attribute argument is an identifier, only consider\n\t second and following arguments. Attributes like mode, format,\n\t cleanup and several target specific attributes aren't late\n\t just because they have an IDENTIFIER_NODE as first argument. */",
"/* We can't apply any attributes to a completely unknown type until\n\t instantiation time. */",
"/* Also defer most attributes on dependent types. This is not\n\t necessary in all cases, but is the better default. */",
"/* But attribute visibility specifically works on\n\t\t templates. */"
] | [
{
"param": "attr",
"type": "tree"
},
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "attr",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | splice_template_attributes | tree | static tree
splice_template_attributes (tree *attr_p, tree decl)
{
tree *p = attr_p;
tree late_attrs = NULL_TREE;
tree *q = &late_attrs;
if (!p)
return NULL_TREE;
for (; *p; )
{
if (is_late_template_attribute (*p, decl))
{
ATTR_IS_DEPENDENT (*p) = 1;
*q = *p;
*p = TREE_CHAIN (*p);
q = &TREE_CHAIN (*q);
*q = NULL_TREE;
}
else
p = &TREE_CHAIN (*p);
}
return late_attrs;
} | /* ATTR_P is a list of attributes. Remove any attributes which need to be
applied at instantiation time and return them. If IS_DEPENDENT is true,
the declaration itself is dependent, so all attributes should be applied
at instantiation time. */ | ATTR_P is a list of attributes. Remove any attributes which need to be
applied at instantiation time and return them. If IS_DEPENDENT is true,
the declaration itself is dependent, so all attributes should be applied
at instantiation time. | [
"ATTR_P",
"is",
"a",
"list",
"of",
"attributes",
".",
"Remove",
"any",
"attributes",
"which",
"need",
"to",
"be",
"applied",
"at",
"instantiation",
"time",
"and",
"return",
"them",
".",
"If",
"IS_DEPENDENT",
"is",
"true",
"the",
"declaration",
"itself",
"is",
"dependent",
"so",
"all",
"attributes",
"should",
"be",
"applied",
"at",
"instantiation",
"time",
"."
] | static tree
splice_template_attributes (tree *attr_p, tree decl)
{
tree *p = attr_p;
tree late_attrs = NULL_TREE;
tree *q = &late_attrs;
if (!p)
return NULL_TREE;
for (; *p; )
{
if (is_late_template_attribute (*p, decl))
{
ATTR_IS_DEPENDENT (*p) = 1;
*q = *p;
*p = TREE_CHAIN (*p);
q = &TREE_CHAIN (*q);
*q = NULL_TREE;
}
else
p = &TREE_CHAIN (*p);
}
return late_attrs;
} | [
"static",
"tree",
"splice_template_attributes",
"(",
"tree",
"*",
"attr_p",
",",
"tree",
"decl",
")",
"{",
"tree",
"*",
"p",
"=",
"attr_p",
";",
"tree",
"late_attrs",
"=",
"NULL_TREE",
";",
"tree",
"*",
"q",
"=",
"&",
"late_attrs",
";",
"if",
"(",
"!",
"p",
")",
"return",
"NULL_TREE",
";",
"for",
"(",
";",
"*",
"p",
";",
")",
"{",
"if",
"(",
"is_late_template_attribute",
"(",
"*",
"p",
",",
"decl",
")",
")",
"{",
"ATTR_IS_DEPENDENT",
"(",
"*",
"p",
")",
"=",
"1",
";",
"*",
"q",
"=",
"*",
"p",
";",
"*",
"p",
"=",
"TREE_CHAIN",
"(",
"*",
"p",
")",
";",
"q",
"=",
"&",
"TREE_CHAIN",
"(",
"*",
"q",
")",
";",
"*",
"q",
"=",
"NULL_TREE",
";",
"}",
"else",
"p",
"=",
"&",
"TREE_CHAIN",
"(",
"*",
"p",
")",
";",
"}",
"return",
"late_attrs",
";",
"}"
] | ATTR_P is a list of attributes. | [
"ATTR_P",
"is",
"a",
"list",
"of",
"attributes",
"."
] | [] | [
{
"param": "attr_p",
"type": "tree"
},
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "attr_p",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | save_template_attributes | void | static void
save_template_attributes (tree *attr_p, tree *decl_p)
{
tree late_attrs = splice_template_attributes (attr_p, *decl_p);
tree *q;
tree old_attrs = NULL_TREE;
if (!late_attrs)
return;
if (DECL_P (*decl_p))
q = &DECL_ATTRIBUTES (*decl_p);
else
q = &TYPE_ATTRIBUTES (*decl_p);
old_attrs = *q;
/* Merge the late attributes at the beginning with the attribute
list. */
late_attrs = merge_attributes (late_attrs, *q);
*q = late_attrs;
if (!DECL_P (*decl_p) && *decl_p == TYPE_MAIN_VARIANT (*decl_p))
{
/* We've added new attributes directly to the main variant, so
now we need to update all of the other variants to include
these new attributes. */
tree variant;
for (variant = TYPE_NEXT_VARIANT (*decl_p); variant;
variant = TYPE_NEXT_VARIANT (variant))
{
gcc_assert (TYPE_ATTRIBUTES (variant) == old_attrs);
TYPE_ATTRIBUTES (variant) = TYPE_ATTRIBUTES (*decl_p);
}
}
} | /* Remove any late attributes from the list in ATTR_P and attach them to
DECL_P. */ | Remove any late attributes from the list in ATTR_P and attach them to
DECL_P. | [
"Remove",
"any",
"late",
"attributes",
"from",
"the",
"list",
"in",
"ATTR_P",
"and",
"attach",
"them",
"to",
"DECL_P",
"."
] | static void
save_template_attributes (tree *attr_p, tree *decl_p)
{
tree late_attrs = splice_template_attributes (attr_p, *decl_p);
tree *q;
tree old_attrs = NULL_TREE;
if (!late_attrs)
return;
if (DECL_P (*decl_p))
q = &DECL_ATTRIBUTES (*decl_p);
else
q = &TYPE_ATTRIBUTES (*decl_p);
old_attrs = *q;
late_attrs = merge_attributes (late_attrs, *q);
*q = late_attrs;
if (!DECL_P (*decl_p) && *decl_p == TYPE_MAIN_VARIANT (*decl_p))
{
tree variant;
for (variant = TYPE_NEXT_VARIANT (*decl_p); variant;
variant = TYPE_NEXT_VARIANT (variant))
{
gcc_assert (TYPE_ATTRIBUTES (variant) == old_attrs);
TYPE_ATTRIBUTES (variant) = TYPE_ATTRIBUTES (*decl_p);
}
}
} | [
"static",
"void",
"save_template_attributes",
"(",
"tree",
"*",
"attr_p",
",",
"tree",
"*",
"decl_p",
")",
"{",
"tree",
"late_attrs",
"=",
"splice_template_attributes",
"(",
"attr_p",
",",
"*",
"decl_p",
")",
";",
"tree",
"*",
"q",
";",
"tree",
"old_attrs",
"=",
"NULL_TREE",
";",
"if",
"(",
"!",
"late_attrs",
")",
"return",
";",
"if",
"(",
"DECL_P",
"(",
"*",
"decl_p",
")",
")",
"q",
"=",
"&",
"DECL_ATTRIBUTES",
"(",
"*",
"decl_p",
")",
";",
"else",
"q",
"=",
"&",
"TYPE_ATTRIBUTES",
"(",
"*",
"decl_p",
")",
";",
"old_attrs",
"=",
"*",
"q",
";",
"late_attrs",
"=",
"merge_attributes",
"(",
"late_attrs",
",",
"*",
"q",
")",
";",
"*",
"q",
"=",
"late_attrs",
";",
"if",
"(",
"!",
"DECL_P",
"(",
"*",
"decl_p",
")",
"&&",
"*",
"decl_p",
"==",
"TYPE_MAIN_VARIANT",
"(",
"*",
"decl_p",
")",
")",
"{",
"tree",
"variant",
";",
"for",
"(",
"variant",
"=",
"TYPE_NEXT_VARIANT",
"(",
"*",
"decl_p",
")",
";",
"variant",
";",
"variant",
"=",
"TYPE_NEXT_VARIANT",
"(",
"variant",
")",
")",
"{",
"gcc_assert",
"(",
"TYPE_ATTRIBUTES",
"(",
"variant",
")",
"==",
"old_attrs",
")",
";",
"TYPE_ATTRIBUTES",
"(",
"variant",
")",
"=",
"TYPE_ATTRIBUTES",
"(",
"*",
"decl_p",
")",
";",
"}",
"}",
"}"
] | Remove any late attributes from the list in ATTR_P and attach them to
DECL_P. | [
"Remove",
"any",
"late",
"attributes",
"from",
"the",
"list",
"in",
"ATTR_P",
"and",
"attach",
"them",
"to",
"DECL_P",
"."
] | [
"/* Merge the late attributes at the beginning with the attribute\n list. */",
"/* We've added new attributes directly to the main variant, so\n\t now we need to update all of the other variants to include\n\t these new attributes. */"
] | [
{
"param": "attr_p",
"type": "tree"
},
{
"param": "decl_p",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "attr_p",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "decl_p",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | cp_reconstruct_complex_type | tree | tree
cp_reconstruct_complex_type (tree type, tree bottom)
{
tree inner, outer;
if (TREE_CODE (type) == POINTER_TYPE)
{
inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
TYPE_REF_CAN_ALIAS_ALL (type));
}
else if (TREE_CODE (type) == REFERENCE_TYPE)
{
inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
TYPE_REF_CAN_ALIAS_ALL (type));
}
else if (TREE_CODE (type) == ARRAY_TYPE)
{
inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
outer = build_cplus_array_type (inner, TYPE_DOMAIN (type));
/* Don't call cp_build_qualified_type on ARRAY_TYPEs, the
element type qualification will be handled by the recursive
cp_reconstruct_complex_type call and cp_build_qualified_type
for ARRAY_TYPEs changes the element type. */
return outer;
}
else if (TREE_CODE (type) == FUNCTION_TYPE)
{
inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
outer = build_function_type (inner, TYPE_ARG_TYPES (type));
outer = apply_memfn_quals (outer, type_memfn_quals (type));
}
else if (TREE_CODE (type) == METHOD_TYPE)
{
inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
/* The build_method_type_directly() routine prepends 'this' to argument list,
so we must compensate by getting rid of it. */
outer
= build_method_type_directly
(class_of_this_parm (type), inner,
TREE_CHAIN (TYPE_ARG_TYPES (type)));
}
else if (TREE_CODE (type) == OFFSET_TYPE)
{
inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
}
else
return bottom;
if (TYPE_ATTRIBUTES (type))
outer = cp_build_type_attribute_variant (outer, TYPE_ATTRIBUTES (type));
return cp_build_qualified_type (outer, cp_type_quals (type));
} | /* Like reconstruct_complex_type, but handle also template trees. */ | Like reconstruct_complex_type, but handle also template trees. | [
"Like",
"reconstruct_complex_type",
"but",
"handle",
"also",
"template",
"trees",
"."
] | tree
cp_reconstruct_complex_type (tree type, tree bottom)
{
tree inner, outer;
if (TREE_CODE (type) == POINTER_TYPE)
{
inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
TYPE_REF_CAN_ALIAS_ALL (type));
}
else if (TREE_CODE (type) == REFERENCE_TYPE)
{
inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
TYPE_REF_CAN_ALIAS_ALL (type));
}
else if (TREE_CODE (type) == ARRAY_TYPE)
{
inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
outer = build_cplus_array_type (inner, TYPE_DOMAIN (type));
return outer;
}
else if (TREE_CODE (type) == FUNCTION_TYPE)
{
inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
outer = build_function_type (inner, TYPE_ARG_TYPES (type));
outer = apply_memfn_quals (outer, type_memfn_quals (type));
}
else if (TREE_CODE (type) == METHOD_TYPE)
{
inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
outer
= build_method_type_directly
(class_of_this_parm (type), inner,
TREE_CHAIN (TYPE_ARG_TYPES (type)));
}
else if (TREE_CODE (type) == OFFSET_TYPE)
{
inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
}
else
return bottom;
if (TYPE_ATTRIBUTES (type))
outer = cp_build_type_attribute_variant (outer, TYPE_ATTRIBUTES (type));
return cp_build_qualified_type (outer, cp_type_quals (type));
} | [
"tree",
"cp_reconstruct_complex_type",
"(",
"tree",
"type",
",",
"tree",
"bottom",
")",
"{",
"tree",
"inner",
",",
"outer",
";",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"POINTER_TYPE",
")",
"{",
"inner",
"=",
"cp_reconstruct_complex_type",
"(",
"TREE_TYPE",
"(",
"type",
")",
",",
"bottom",
")",
";",
"outer",
"=",
"build_pointer_type_for_mode",
"(",
"inner",
",",
"TYPE_MODE",
"(",
"type",
")",
",",
"TYPE_REF_CAN_ALIAS_ALL",
"(",
"type",
")",
")",
";",
"}",
"else",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"REFERENCE_TYPE",
")",
"{",
"inner",
"=",
"cp_reconstruct_complex_type",
"(",
"TREE_TYPE",
"(",
"type",
")",
",",
"bottom",
")",
";",
"outer",
"=",
"build_reference_type_for_mode",
"(",
"inner",
",",
"TYPE_MODE",
"(",
"type",
")",
",",
"TYPE_REF_CAN_ALIAS_ALL",
"(",
"type",
")",
")",
";",
"}",
"else",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"ARRAY_TYPE",
")",
"{",
"inner",
"=",
"cp_reconstruct_complex_type",
"(",
"TREE_TYPE",
"(",
"type",
")",
",",
"bottom",
")",
";",
"outer",
"=",
"build_cplus_array_type",
"(",
"inner",
",",
"TYPE_DOMAIN",
"(",
"type",
")",
")",
";",
"return",
"outer",
";",
"}",
"else",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"FUNCTION_TYPE",
")",
"{",
"inner",
"=",
"cp_reconstruct_complex_type",
"(",
"TREE_TYPE",
"(",
"type",
")",
",",
"bottom",
")",
";",
"outer",
"=",
"build_function_type",
"(",
"inner",
",",
"TYPE_ARG_TYPES",
"(",
"type",
")",
")",
";",
"outer",
"=",
"apply_memfn_quals",
"(",
"outer",
",",
"type_memfn_quals",
"(",
"type",
")",
")",
";",
"}",
"else",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"METHOD_TYPE",
")",
"{",
"inner",
"=",
"cp_reconstruct_complex_type",
"(",
"TREE_TYPE",
"(",
"type",
")",
",",
"bottom",
")",
";",
"outer",
"=",
"build_method_type_directly",
"(",
"class_of_this_parm",
"(",
"type",
")",
",",
"inner",
",",
"TREE_CHAIN",
"(",
"TYPE_ARG_TYPES",
"(",
"type",
")",
")",
")",
";",
"}",
"else",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"OFFSET_TYPE",
")",
"{",
"inner",
"=",
"cp_reconstruct_complex_type",
"(",
"TREE_TYPE",
"(",
"type",
")",
",",
"bottom",
")",
";",
"outer",
"=",
"build_offset_type",
"(",
"TYPE_OFFSET_BASETYPE",
"(",
"type",
")",
",",
"inner",
")",
";",
"}",
"else",
"return",
"bottom",
";",
"if",
"(",
"TYPE_ATTRIBUTES",
"(",
"type",
")",
")",
"outer",
"=",
"cp_build_type_attribute_variant",
"(",
"outer",
",",
"TYPE_ATTRIBUTES",
"(",
"type",
")",
")",
";",
"return",
"cp_build_qualified_type",
"(",
"outer",
",",
"cp_type_quals",
"(",
"type",
")",
")",
";",
"}"
] | Like reconstruct_complex_type, but handle also template trees. | [
"Like",
"reconstruct_complex_type",
"but",
"handle",
"also",
"template",
"trees",
"."
] | [
"/* Don't call cp_build_qualified_type on ARRAY_TYPEs, the\n\t element type qualification will be handled by the recursive\n\t cp_reconstruct_complex_type call and cp_build_qualified_type\n\t for ARRAY_TYPEs changes the element type. */",
"/* The build_method_type_directly() routine prepends 'this' to argument list,\n\t so we must compensate by getting rid of it. */"
] | [
{
"param": "type",
"type": "tree"
},
{
"param": "bottom",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "type",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "bottom",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | cp_check_const_attributes | void | static void
cp_check_const_attributes (tree attributes)
{
tree attr;
for (attr = attributes; attr; attr = TREE_CHAIN (attr))
{
tree arg;
for (arg = TREE_VALUE (attr); arg; arg = TREE_CHAIN (arg))
{
tree expr = TREE_VALUE (arg);
if (EXPR_P (expr))
TREE_VALUE (arg) = maybe_constant_value (expr);
}
}
} | /* Replaces any constexpr expression that may be into the attributes
arguments with their reduced value. */ | Replaces any constexpr expression that may be into the attributes
arguments with their reduced value. | [
"Replaces",
"any",
"constexpr",
"expression",
"that",
"may",
"be",
"into",
"the",
"attributes",
"arguments",
"with",
"their",
"reduced",
"value",
"."
] | static void
cp_check_const_attributes (tree attributes)
{
tree attr;
for (attr = attributes; attr; attr = TREE_CHAIN (attr))
{
tree arg;
for (arg = TREE_VALUE (attr); arg; arg = TREE_CHAIN (arg))
{
tree expr = TREE_VALUE (arg);
if (EXPR_P (expr))
TREE_VALUE (arg) = maybe_constant_value (expr);
}
}
} | [
"static",
"void",
"cp_check_const_attributes",
"(",
"tree",
"attributes",
")",
"{",
"tree",
"attr",
";",
"for",
"(",
"attr",
"=",
"attributes",
";",
"attr",
";",
"attr",
"=",
"TREE_CHAIN",
"(",
"attr",
")",
")",
"{",
"tree",
"arg",
";",
"for",
"(",
"arg",
"=",
"TREE_VALUE",
"(",
"attr",
")",
";",
"arg",
";",
"arg",
"=",
"TREE_CHAIN",
"(",
"arg",
")",
")",
"{",
"tree",
"expr",
"=",
"TREE_VALUE",
"(",
"arg",
")",
";",
"if",
"(",
"EXPR_P",
"(",
"expr",
")",
")",
"TREE_VALUE",
"(",
"arg",
")",
"=",
"maybe_constant_value",
"(",
"expr",
")",
";",
"}",
"}",
"}"
] | Replaces any constexpr expression that may be into the attributes
arguments with their reduced value. | [
"Replaces",
"any",
"constexpr",
"expression",
"that",
"may",
"be",
"into",
"the",
"attributes",
"arguments",
"with",
"their",
"reduced",
"value",
"."
] | [] | [
{
"param": "attributes",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "attributes",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | build_anon_union_vars | tree | static tree
build_anon_union_vars (tree type, tree object)
{
tree main_decl = NULL_TREE;
tree field;
/* Rather than write the code to handle the non-union case,
just give an error. */
if (TREE_CODE (type) != UNION_TYPE)
{
error ("anonymous struct not inside named type");
return error_mark_node;
}
for (field = TYPE_FIELDS (type);
field != NULL_TREE;
field = DECL_CHAIN (field))
{
tree decl;
tree ref;
if (DECL_ARTIFICIAL (field))
continue;
if (TREE_CODE (field) != FIELD_DECL)
{
permerror (input_location, "%q+#D invalid; an anonymous union can only "
"have non-static data members", field);
continue;
}
if (TREE_PRIVATE (field))
permerror (input_location, "private member %q+#D in anonymous union", field);
else if (TREE_PROTECTED (field))
permerror (input_location, "protected member %q+#D in anonymous union", field);
if (processing_template_decl)
ref = build_min_nt (COMPONENT_REF, object,
DECL_NAME (field), NULL_TREE);
else
ref = build_class_member_access_expr (object, field, NULL_TREE,
false, tf_warning_or_error);
if (DECL_NAME (field))
{
tree base;
decl = build_decl (input_location,
VAR_DECL, DECL_NAME (field), TREE_TYPE (field));
DECL_ANON_UNION_VAR_P (decl) = 1;
DECL_ARTIFICIAL (decl) = 1;
base = get_base_address (object);
TREE_PUBLIC (decl) = TREE_PUBLIC (base);
TREE_STATIC (decl) = TREE_STATIC (base);
DECL_EXTERNAL (decl) = DECL_EXTERNAL (base);
SET_DECL_VALUE_EXPR (decl, ref);
DECL_HAS_VALUE_EXPR_P (decl) = 1;
decl = pushdecl (decl);
}
else if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
decl = build_anon_union_vars (TREE_TYPE (field), ref);
else
decl = 0;
if (main_decl == NULL_TREE)
main_decl = decl;
}
return main_decl;
} | /* Walks through the namespace- or function-scope anonymous union
OBJECT, with the indicated TYPE, building appropriate VAR_DECLs.
Returns one of the fields for use in the mangled name. */ | Walks through the namespace- or function-scope anonymous union
OBJECT, with the indicated TYPE, building appropriate VAR_DECLs.
Returns one of the fields for use in the mangled name. | [
"Walks",
"through",
"the",
"namespace",
"-",
"or",
"function",
"-",
"scope",
"anonymous",
"union",
"OBJECT",
"with",
"the",
"indicated",
"TYPE",
"building",
"appropriate",
"VAR_DECLs",
".",
"Returns",
"one",
"of",
"the",
"fields",
"for",
"use",
"in",
"the",
"mangled",
"name",
"."
] | static tree
build_anon_union_vars (tree type, tree object)
{
tree main_decl = NULL_TREE;
tree field;
if (TREE_CODE (type) != UNION_TYPE)
{
error ("anonymous struct not inside named type");
return error_mark_node;
}
for (field = TYPE_FIELDS (type);
field != NULL_TREE;
field = DECL_CHAIN (field))
{
tree decl;
tree ref;
if (DECL_ARTIFICIAL (field))
continue;
if (TREE_CODE (field) != FIELD_DECL)
{
permerror (input_location, "%q+#D invalid; an anonymous union can only "
"have non-static data members", field);
continue;
}
if (TREE_PRIVATE (field))
permerror (input_location, "private member %q+#D in anonymous union", field);
else if (TREE_PROTECTED (field))
permerror (input_location, "protected member %q+#D in anonymous union", field);
if (processing_template_decl)
ref = build_min_nt (COMPONENT_REF, object,
DECL_NAME (field), NULL_TREE);
else
ref = build_class_member_access_expr (object, field, NULL_TREE,
false, tf_warning_or_error);
if (DECL_NAME (field))
{
tree base;
decl = build_decl (input_location,
VAR_DECL, DECL_NAME (field), TREE_TYPE (field));
DECL_ANON_UNION_VAR_P (decl) = 1;
DECL_ARTIFICIAL (decl) = 1;
base = get_base_address (object);
TREE_PUBLIC (decl) = TREE_PUBLIC (base);
TREE_STATIC (decl) = TREE_STATIC (base);
DECL_EXTERNAL (decl) = DECL_EXTERNAL (base);
SET_DECL_VALUE_EXPR (decl, ref);
DECL_HAS_VALUE_EXPR_P (decl) = 1;
decl = pushdecl (decl);
}
else if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
decl = build_anon_union_vars (TREE_TYPE (field), ref);
else
decl = 0;
if (main_decl == NULL_TREE)
main_decl = decl;
}
return main_decl;
} | [
"static",
"tree",
"build_anon_union_vars",
"(",
"tree",
"type",
",",
"tree",
"object",
")",
"{",
"tree",
"main_decl",
"=",
"NULL_TREE",
";",
"tree",
"field",
";",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"!=",
"UNION_TYPE",
")",
"{",
"error",
"(",
"\"",
"\"",
")",
";",
"return",
"error_mark_node",
";",
"}",
"for",
"(",
"field",
"=",
"TYPE_FIELDS",
"(",
"type",
")",
";",
"field",
"!=",
"NULL_TREE",
";",
"field",
"=",
"DECL_CHAIN",
"(",
"field",
")",
")",
"{",
"tree",
"decl",
";",
"tree",
"ref",
";",
"if",
"(",
"DECL_ARTIFICIAL",
"(",
"field",
")",
")",
"continue",
";",
"if",
"(",
"TREE_CODE",
"(",
"field",
")",
"!=",
"FIELD_DECL",
")",
"{",
"permerror",
"(",
"input_location",
",",
"\"",
"\"",
"\"",
"\"",
",",
"field",
")",
";",
"continue",
";",
"}",
"if",
"(",
"TREE_PRIVATE",
"(",
"field",
")",
")",
"permerror",
"(",
"input_location",
",",
"\"",
"\"",
",",
"field",
")",
";",
"else",
"if",
"(",
"TREE_PROTECTED",
"(",
"field",
")",
")",
"permerror",
"(",
"input_location",
",",
"\"",
"\"",
",",
"field",
")",
";",
"if",
"(",
"processing_template_decl",
")",
"ref",
"=",
"build_min_nt",
"(",
"COMPONENT_REF",
",",
"object",
",",
"DECL_NAME",
"(",
"field",
")",
",",
"NULL_TREE",
")",
";",
"else",
"ref",
"=",
"build_class_member_access_expr",
"(",
"object",
",",
"field",
",",
"NULL_TREE",
",",
"false",
",",
"tf_warning_or_error",
")",
";",
"if",
"(",
"DECL_NAME",
"(",
"field",
")",
")",
"{",
"tree",
"base",
";",
"decl",
"=",
"build_decl",
"(",
"input_location",
",",
"VAR_DECL",
",",
"DECL_NAME",
"(",
"field",
")",
",",
"TREE_TYPE",
"(",
"field",
")",
")",
";",
"DECL_ANON_UNION_VAR_P",
"(",
"decl",
")",
"=",
"1",
";",
"DECL_ARTIFICIAL",
"(",
"decl",
")",
"=",
"1",
";",
"base",
"=",
"get_base_address",
"(",
"object",
")",
";",
"TREE_PUBLIC",
"(",
"decl",
")",
"=",
"TREE_PUBLIC",
"(",
"base",
")",
";",
"TREE_STATIC",
"(",
"decl",
")",
"=",
"TREE_STATIC",
"(",
"base",
")",
";",
"DECL_EXTERNAL",
"(",
"decl",
")",
"=",
"DECL_EXTERNAL",
"(",
"base",
")",
";",
"SET_DECL_VALUE_EXPR",
"(",
"decl",
",",
"ref",
")",
";",
"DECL_HAS_VALUE_EXPR_P",
"(",
"decl",
")",
"=",
"1",
";",
"decl",
"=",
"pushdecl",
"(",
"decl",
")",
";",
"}",
"else",
"if",
"(",
"ANON_AGGR_TYPE_P",
"(",
"TREE_TYPE",
"(",
"field",
")",
")",
")",
"decl",
"=",
"build_anon_union_vars",
"(",
"TREE_TYPE",
"(",
"field",
")",
",",
"ref",
")",
";",
"else",
"decl",
"=",
"0",
";",
"if",
"(",
"main_decl",
"==",
"NULL_TREE",
")",
"main_decl",
"=",
"decl",
";",
"}",
"return",
"main_decl",
";",
"}"
] | Walks through the namespace- or function-scope anonymous union
OBJECT, with the indicated TYPE, building appropriate VAR_DECLs. | [
"Walks",
"through",
"the",
"namespace",
"-",
"or",
"function",
"-",
"scope",
"anonymous",
"union",
"OBJECT",
"with",
"the",
"indicated",
"TYPE",
"building",
"appropriate",
"VAR_DECLs",
"."
] | [
"/* Rather than write the code to handle the non-union case,\n just give an error. */"
] | [
{
"param": "type",
"type": "tree"
},
{
"param": "object",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "type",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "object",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | finish_anon_union | void | void
finish_anon_union (tree anon_union_decl)
{
tree type;
tree main_decl;
bool public_p;
if (anon_union_decl == error_mark_node)
return;
type = TREE_TYPE (anon_union_decl);
public_p = TREE_PUBLIC (anon_union_decl);
/* The VAR_DECL's context is the same as the TYPE's context. */
DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type));
if (TYPE_FIELDS (type) == NULL_TREE)
return;
if (public_p)
{
error ("namespace-scope anonymous aggregates must be static");
return;
}
main_decl = build_anon_union_vars (type, anon_union_decl);
if (main_decl == error_mark_node)
return;
if (main_decl == NULL_TREE)
{
warning (0, "anonymous union with no members");
return;
}
if (!processing_template_decl)
{
/* Use main_decl to set the mangled name. */
DECL_NAME (anon_union_decl) = DECL_NAME (main_decl);
maybe_commonize_var (anon_union_decl);
if (TREE_STATIC (anon_union_decl) || DECL_EXTERNAL (anon_union_decl))
mangle_decl (anon_union_decl);
DECL_NAME (anon_union_decl) = NULL_TREE;
}
pushdecl (anon_union_decl);
if (building_stmt_list_p ()
&& at_function_scope_p ())
add_decl_expr (anon_union_decl);
else if (!processing_template_decl)
rest_of_decl_compilation (anon_union_decl,
toplevel_bindings_p (), at_eof);
} | /* Finish off the processing of a UNION_TYPE structure. If the union is an
anonymous union, then all members must be laid out together. PUBLIC_P
is nonzero if this union is not declared static. */ | Finish off the processing of a UNION_TYPE structure. If the union is an
anonymous union, then all members must be laid out together. PUBLIC_P
is nonzero if this union is not declared static. | [
"Finish",
"off",
"the",
"processing",
"of",
"a",
"UNION_TYPE",
"structure",
".",
"If",
"the",
"union",
"is",
"an",
"anonymous",
"union",
"then",
"all",
"members",
"must",
"be",
"laid",
"out",
"together",
".",
"PUBLIC_P",
"is",
"nonzero",
"if",
"this",
"union",
"is",
"not",
"declared",
"static",
"."
] | void
finish_anon_union (tree anon_union_decl)
{
tree type;
tree main_decl;
bool public_p;
if (anon_union_decl == error_mark_node)
return;
type = TREE_TYPE (anon_union_decl);
public_p = TREE_PUBLIC (anon_union_decl);
DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type));
if (TYPE_FIELDS (type) == NULL_TREE)
return;
if (public_p)
{
error ("namespace-scope anonymous aggregates must be static");
return;
}
main_decl = build_anon_union_vars (type, anon_union_decl);
if (main_decl == error_mark_node)
return;
if (main_decl == NULL_TREE)
{
warning (0, "anonymous union with no members");
return;
}
if (!processing_template_decl)
{
DECL_NAME (anon_union_decl) = DECL_NAME (main_decl);
maybe_commonize_var (anon_union_decl);
if (TREE_STATIC (anon_union_decl) || DECL_EXTERNAL (anon_union_decl))
mangle_decl (anon_union_decl);
DECL_NAME (anon_union_decl) = NULL_TREE;
}
pushdecl (anon_union_decl);
if (building_stmt_list_p ()
&& at_function_scope_p ())
add_decl_expr (anon_union_decl);
else if (!processing_template_decl)
rest_of_decl_compilation (anon_union_decl,
toplevel_bindings_p (), at_eof);
} | [
"void",
"finish_anon_union",
"(",
"tree",
"anon_union_decl",
")",
"{",
"tree",
"type",
";",
"tree",
"main_decl",
";",
"bool",
"public_p",
";",
"if",
"(",
"anon_union_decl",
"==",
"error_mark_node",
")",
"return",
";",
"type",
"=",
"TREE_TYPE",
"(",
"anon_union_decl",
")",
";",
"public_p",
"=",
"TREE_PUBLIC",
"(",
"anon_union_decl",
")",
";",
"DECL_CONTEXT",
"(",
"anon_union_decl",
")",
"=",
"DECL_CONTEXT",
"(",
"TYPE_NAME",
"(",
"type",
")",
")",
";",
"if",
"(",
"TYPE_FIELDS",
"(",
"type",
")",
"==",
"NULL_TREE",
")",
"return",
";",
"if",
"(",
"public_p",
")",
"{",
"error",
"(",
"\"",
"\"",
")",
";",
"return",
";",
"}",
"main_decl",
"=",
"build_anon_union_vars",
"(",
"type",
",",
"anon_union_decl",
")",
";",
"if",
"(",
"main_decl",
"==",
"error_mark_node",
")",
"return",
";",
"if",
"(",
"main_decl",
"==",
"NULL_TREE",
")",
"{",
"warning",
"(",
"0",
",",
"\"",
"\"",
")",
";",
"return",
";",
"}",
"if",
"(",
"!",
"processing_template_decl",
")",
"{",
"DECL_NAME",
"(",
"anon_union_decl",
")",
"=",
"DECL_NAME",
"(",
"main_decl",
")",
";",
"maybe_commonize_var",
"(",
"anon_union_decl",
")",
";",
"if",
"(",
"TREE_STATIC",
"(",
"anon_union_decl",
")",
"||",
"DECL_EXTERNAL",
"(",
"anon_union_decl",
")",
")",
"mangle_decl",
"(",
"anon_union_decl",
")",
";",
"DECL_NAME",
"(",
"anon_union_decl",
")",
"=",
"NULL_TREE",
";",
"}",
"pushdecl",
"(",
"anon_union_decl",
")",
";",
"if",
"(",
"building_stmt_list_p",
"(",
")",
"&&",
"at_function_scope_p",
"(",
")",
")",
"add_decl_expr",
"(",
"anon_union_decl",
")",
";",
"else",
"if",
"(",
"!",
"processing_template_decl",
")",
"rest_of_decl_compilation",
"(",
"anon_union_decl",
",",
"toplevel_bindings_p",
"(",
")",
",",
"at_eof",
")",
";",
"}"
] | Finish off the processing of a UNION_TYPE structure. | [
"Finish",
"off",
"the",
"processing",
"of",
"a",
"UNION_TYPE",
"structure",
"."
] | [
"/* The VAR_DECL's context is the same as the TYPE's context. */",
"/* Use main_decl to set the mangled name. */"
] | [
{
"param": "anon_union_decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "anon_union_decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | coerce_new_type | tree | tree
coerce_new_type (tree type)
{
int e = 0;
tree args = TYPE_ARG_TYPES (type);
gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
if (!same_type_p (TREE_TYPE (type), ptr_type_node))
{
e = 1;
error ("%<operator new%> must return type %qT", ptr_type_node);
}
if (args && args != void_list_node)
{
if (TREE_PURPOSE (args))
{
/* [basic.stc.dynamic.allocation]
The first parameter shall not have an associated default
argument. */
error ("the first parameter of %<operator new%> cannot "
"have a default argument");
/* Throw away the default argument. */
TREE_PURPOSE (args) = NULL_TREE;
}
if (!same_type_p (TREE_VALUE (args), size_type_node))
{
e = 2;
args = TREE_CHAIN (args);
}
}
else
e = 2;
if (e == 2)
permerror (input_location, "%<operator new%> takes type %<size_t%> (%qT) "
"as first parameter", size_type_node);
switch (e)
{
case 2:
args = tree_cons (NULL_TREE, size_type_node, args);
/* Fall through. */
case 1:
type = build_exception_variant
(build_function_type (ptr_type_node, args),
TYPE_RAISES_EXCEPTIONS (type));
/* Fall through. */
default:;
}
return type;
} | /* Auxiliary functions to make type signatures for
`operator new' and `operator delete' correspond to
what compiler will be expecting. */ | Auxiliary functions to make type signatures for
`operator new' and `operator delete' correspond to
what compiler will be expecting. | [
"Auxiliary",
"functions",
"to",
"make",
"type",
"signatures",
"for",
"`",
"operator",
"new",
"'",
"and",
"`",
"operator",
"delete",
"'",
"correspond",
"to",
"what",
"compiler",
"will",
"be",
"expecting",
"."
] | tree
coerce_new_type (tree type)
{
int e = 0;
tree args = TYPE_ARG_TYPES (type);
gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
if (!same_type_p (TREE_TYPE (type), ptr_type_node))
{
e = 1;
error ("%<operator new%> must return type %qT", ptr_type_node);
}
if (args && args != void_list_node)
{
if (TREE_PURPOSE (args))
{
error ("the first parameter of %<operator new%> cannot "
"have a default argument");
TREE_PURPOSE (args) = NULL_TREE;
}
if (!same_type_p (TREE_VALUE (args), size_type_node))
{
e = 2;
args = TREE_CHAIN (args);
}
}
else
e = 2;
if (e == 2)
permerror (input_location, "%<operator new%> takes type %<size_t%> (%qT) "
"as first parameter", size_type_node);
switch (e)
{
case 2:
args = tree_cons (NULL_TREE, size_type_node, args);
case 1:
type = build_exception_variant
(build_function_type (ptr_type_node, args),
TYPE_RAISES_EXCEPTIONS (type));
default:;
}
return type;
} | [
"tree",
"coerce_new_type",
"(",
"tree",
"type",
")",
"{",
"int",
"e",
"=",
"0",
";",
"tree",
"args",
"=",
"TYPE_ARG_TYPES",
"(",
"type",
")",
";",
"gcc_assert",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"FUNCTION_TYPE",
")",
";",
"if",
"(",
"!",
"same_type_p",
"(",
"TREE_TYPE",
"(",
"type",
")",
",",
"ptr_type_node",
")",
")",
"{",
"e",
"=",
"1",
";",
"error",
"(",
"\"",
"\"",
",",
"ptr_type_node",
")",
";",
"}",
"if",
"(",
"args",
"&&",
"args",
"!=",
"void_list_node",
")",
"{",
"if",
"(",
"TREE_PURPOSE",
"(",
"args",
")",
")",
"{",
"error",
"(",
"\"",
"\"",
"\"",
"\"",
")",
";",
"TREE_PURPOSE",
"(",
"args",
")",
"=",
"NULL_TREE",
";",
"}",
"if",
"(",
"!",
"same_type_p",
"(",
"TREE_VALUE",
"(",
"args",
")",
",",
"size_type_node",
")",
")",
"{",
"e",
"=",
"2",
";",
"args",
"=",
"TREE_CHAIN",
"(",
"args",
")",
";",
"}",
"}",
"else",
"e",
"=",
"2",
";",
"if",
"(",
"e",
"==",
"2",
")",
"permerror",
"(",
"input_location",
",",
"\"",
"\"",
"\"",
"\"",
",",
"size_type_node",
")",
";",
"switch",
"(",
"e",
")",
"{",
"case",
"2",
":",
"args",
"=",
"tree_cons",
"(",
"NULL_TREE",
",",
"size_type_node",
",",
"args",
")",
";",
"case",
"1",
":",
"type",
"=",
"build_exception_variant",
"(",
"build_function_type",
"(",
"ptr_type_node",
",",
"args",
")",
",",
"TYPE_RAISES_EXCEPTIONS",
"(",
"type",
")",
")",
";",
"default",
":",
";",
"}",
"return",
"type",
";",
"}"
] | Auxiliary functions to make type signatures for
`operator new' and `operator delete' correspond to
what compiler will be expecting. | [
"Auxiliary",
"functions",
"to",
"make",
"type",
"signatures",
"for",
"`",
"operator",
"new",
"'",
"and",
"`",
"operator",
"delete",
"'",
"correspond",
"to",
"what",
"compiler",
"will",
"be",
"expecting",
"."
] | [
"/* [basic.stc.dynamic.allocation]\n\t \n\t The first parameter shall not have an associated default\n\t argument. */",
"/* Throw away the default argument. */",
"/* Fall through. */",
"/* Fall through. */"
] | [
{
"param": "type",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "type",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | mark_vtable_entries | void | static void
mark_vtable_entries (tree decl)
{
tree fnaddr;
unsigned HOST_WIDE_INT idx;
FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)),
idx, fnaddr)
{
tree fn;
STRIP_NOPS (fnaddr);
if (TREE_CODE (fnaddr) != ADDR_EXPR
&& TREE_CODE (fnaddr) != FDESC_EXPR)
/* This entry is an offset: a virtual base class offset, a
virtual call offset, an RTTI offset, etc. */
continue;
fn = TREE_OPERAND (fnaddr, 0);
TREE_ADDRESSABLE (fn) = 1;
/* When we don't have vcall offsets, we output thunks whenever
we output the vtables that contain them. With vcall offsets,
we know all the thunks we'll need when we emit a virtual
function, so we emit the thunks there instead. */
if (DECL_THUNK_P (fn))
use_thunk (fn, /*emit_p=*/0);
mark_used (fn);
}
} | /* DECL is a VAR_DECL for a vtable: walk through the entries in the vtable
and mark them as needed. */ | DECL is a VAR_DECL for a vtable: walk through the entries in the vtable
and mark them as needed. | [
"DECL",
"is",
"a",
"VAR_DECL",
"for",
"a",
"vtable",
":",
"walk",
"through",
"the",
"entries",
"in",
"the",
"vtable",
"and",
"mark",
"them",
"as",
"needed",
"."
] | static void
mark_vtable_entries (tree decl)
{
tree fnaddr;
unsigned HOST_WIDE_INT idx;
FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)),
idx, fnaddr)
{
tree fn;
STRIP_NOPS (fnaddr);
if (TREE_CODE (fnaddr) != ADDR_EXPR
&& TREE_CODE (fnaddr) != FDESC_EXPR)
continue;
fn = TREE_OPERAND (fnaddr, 0);
TREE_ADDRESSABLE (fn) = 1;
if (DECL_THUNK_P (fn))
use_thunk (fn, 0);
mark_used (fn);
}
} | [
"static",
"void",
"mark_vtable_entries",
"(",
"tree",
"decl",
")",
"{",
"tree",
"fnaddr",
";",
"unsigned",
"HOST_WIDE_INT",
"idx",
";",
"FOR_EACH_CONSTRUCTOR_VALUE",
"(",
"CONSTRUCTOR_ELTS",
"(",
"DECL_INITIAL",
"(",
"decl",
")",
")",
",",
"idx",
",",
"fnaddr",
")",
"",
"{",
"tree",
"fn",
";",
"STRIP_NOPS",
"(",
"fnaddr",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"fnaddr",
")",
"!=",
"ADDR_EXPR",
"&&",
"TREE_CODE",
"(",
"fnaddr",
")",
"!=",
"FDESC_EXPR",
")",
"continue",
";",
"fn",
"=",
"TREE_OPERAND",
"(",
"fnaddr",
",",
"0",
")",
";",
"TREE_ADDRESSABLE",
"(",
"fn",
")",
"=",
"1",
";",
"if",
"(",
"DECL_THUNK_P",
"(",
"fn",
")",
")",
"use_thunk",
"(",
"fn",
",",
"0",
")",
";",
"mark_used",
"(",
"fn",
")",
";",
"}",
"}"
] | DECL is a VAR_DECL for a vtable: walk through the entries in the vtable
and mark them as needed. | [
"DECL",
"is",
"a",
"VAR_DECL",
"for",
"a",
"vtable",
":",
"walk",
"through",
"the",
"entries",
"in",
"the",
"vtable",
"and",
"mark",
"them",
"as",
"needed",
"."
] | [
"/* This entry is an offset: a virtual base class offset, a\n\t virtual call offset, an RTTI offset, etc. */",
"/* When we don't have vcall offsets, we output thunks whenever\n\t we output the vtables that contain them. With vcall offsets,\n\t we know all the thunks we'll need when we emit a virtual\n\t function, so we emit the thunks there instead. */",
"/*emit_p=*/"
] | [
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | comdat_linkage | void | void
comdat_linkage (tree decl)
{
if (flag_weak)
make_decl_one_only (decl, cxx_comdat_group (decl));
else if (TREE_CODE (decl) == FUNCTION_DECL
|| (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)))
/* We can just emit function and compiler-generated variables
statically; having multiple copies is (for the most part) only
a waste of space.
There are two correctness issues, however: the address of a
template instantiation with external linkage should be the
same, independent of what translation unit asks for the
address, and this will not hold when we emit multiple copies of
the function. However, there's little else we can do.
Also, by default, the typeinfo implementation assumes that
there will be only one copy of the string used as the name for
each type. Therefore, if weak symbols are unavailable, the
run-time library should perform a more conservative check; it
should perform a string comparison, rather than an address
comparison. */
TREE_PUBLIC (decl) = 0;
else
{
/* Static data member template instantiations, however, cannot
have multiple copies. */
if (DECL_INITIAL (decl) == 0
|| DECL_INITIAL (decl) == error_mark_node)
DECL_COMMON (decl) = 1;
else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
{
DECL_COMMON (decl) = 1;
DECL_INITIAL (decl) = error_mark_node;
}
else if (!DECL_EXPLICIT_INSTANTIATION (decl))
{
/* We can't do anything useful; leave vars for explicit
instantiation. */
DECL_EXTERNAL (decl) = 1;
DECL_NOT_REALLY_EXTERN (decl) = 0;
}
}
DECL_COMDAT (decl) = 1;
} | /* Set DECL up to have the closest approximation of "initialized common"
linkage available. */ | Set DECL up to have the closest approximation of "initialized common"
linkage available. | [
"Set",
"DECL",
"up",
"to",
"have",
"the",
"closest",
"approximation",
"of",
"\"",
"initialized",
"common",
"\"",
"linkage",
"available",
"."
] | void
comdat_linkage (tree decl)
{
if (flag_weak)
make_decl_one_only (decl, cxx_comdat_group (decl));
else if (TREE_CODE (decl) == FUNCTION_DECL
|| (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)))
TREE_PUBLIC (decl) = 0;
else
{
if (DECL_INITIAL (decl) == 0
|| DECL_INITIAL (decl) == error_mark_node)
DECL_COMMON (decl) = 1;
else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
{
DECL_COMMON (decl) = 1;
DECL_INITIAL (decl) = error_mark_node;
}
else if (!DECL_EXPLICIT_INSTANTIATION (decl))
{
DECL_EXTERNAL (decl) = 1;
DECL_NOT_REALLY_EXTERN (decl) = 0;
}
}
DECL_COMDAT (decl) = 1;
} | [
"void",
"comdat_linkage",
"(",
"tree",
"decl",
")",
"{",
"if",
"(",
"flag_weak",
")",
"make_decl_one_only",
"(",
"decl",
",",
"cxx_comdat_group",
"(",
"decl",
")",
")",
";",
"else",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
"||",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"VAR_DECL",
"&&",
"DECL_ARTIFICIAL",
"(",
"decl",
")",
")",
")",
"TREE_PUBLIC",
"(",
"decl",
")",
"=",
"0",
";",
"else",
"{",
"if",
"(",
"DECL_INITIAL",
"(",
"decl",
")",
"==",
"0",
"||",
"DECL_INITIAL",
"(",
"decl",
")",
"==",
"error_mark_node",
")",
"DECL_COMMON",
"(",
"decl",
")",
"=",
"1",
";",
"else",
"if",
"(",
"EMPTY_CONSTRUCTOR_P",
"(",
"DECL_INITIAL",
"(",
"decl",
")",
")",
")",
"{",
"DECL_COMMON",
"(",
"decl",
")",
"=",
"1",
";",
"DECL_INITIAL",
"(",
"decl",
")",
"=",
"error_mark_node",
";",
"}",
"else",
"if",
"(",
"!",
"DECL_EXPLICIT_INSTANTIATION",
"(",
"decl",
")",
")",
"{",
"DECL_EXTERNAL",
"(",
"decl",
")",
"=",
"1",
";",
"DECL_NOT_REALLY_EXTERN",
"(",
"decl",
")",
"=",
"0",
";",
"}",
"}",
"DECL_COMDAT",
"(",
"decl",
")",
"=",
"1",
";",
"}"
] | Set DECL up to have the closest approximation of "initialized common"
linkage available. | [
"Set",
"DECL",
"up",
"to",
"have",
"the",
"closest",
"approximation",
"of",
"\"",
"initialized",
"common",
"\"",
"linkage",
"available",
"."
] | [
"/* We can just emit function and compiler-generated variables\n statically; having multiple copies is (for the most part) only\n a waste of space.\n\n There are two correctness issues, however: the address of a\n template instantiation with external linkage should be the\n same, independent of what translation unit asks for the\n address, and this will not hold when we emit multiple copies of\n the function. However, there's little else we can do.\n\n Also, by default, the typeinfo implementation assumes that\n there will be only one copy of the string used as the name for\n each type. Therefore, if weak symbols are unavailable, the\n run-time library should perform a more conservative check; it\n should perform a string comparison, rather than an address\n comparison. */",
"/* Static data member template instantiations, however, cannot\n\t have multiple copies. */",
"/* We can't do anything useful; leave vars for explicit\n\t instantiation. */"
] | [
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | maybe_make_one_only | void | void
maybe_make_one_only (tree decl)
{
/* We used to say that this was not necessary on targets that support weak
symbols, because the implicit instantiations will defer to the explicit
one. However, that's not actually the case in SVR4; a strong definition
after a weak one is an error. Also, not making explicit
instantiations one_only means that we can end up with two copies of
some template instantiations. */
if (! flag_weak)
return;
/* We can't set DECL_COMDAT on functions, or cp_finish_file will think
we can get away with not emitting them if they aren't used. We need
to for variables so that cp_finish_decl will update their linkage,
because their DECL_INITIAL may not have been set properly yet. */
if (!TARGET_WEAK_NOT_IN_ARCHIVE_TOC
|| (! DECL_EXPLICIT_INSTANTIATION (decl)
&& ! DECL_TEMPLATE_SPECIALIZATION (decl)))
{
make_decl_one_only (decl, cxx_comdat_group (decl));
if (TREE_CODE (decl) == VAR_DECL)
{
DECL_COMDAT (decl) = 1;
/* Mark it needed so we don't forget to emit it. */
mark_decl_referenced (decl);
}
}
} | /* For win32 we also want to put explicit instantiations in
linkonce sections, so that they will be merged with implicit
instantiations; otherwise we get duplicate symbol errors.
For Darwin we do not want explicit instantiations to be
linkonce. */ | For win32 we also want to put explicit instantiations in
linkonce sections, so that they will be merged with implicit
instantiations; otherwise we get duplicate symbol errors.
For Darwin we do not want explicit instantiations to be
linkonce. | [
"For",
"win32",
"we",
"also",
"want",
"to",
"put",
"explicit",
"instantiations",
"in",
"linkonce",
"sections",
"so",
"that",
"they",
"will",
"be",
"merged",
"with",
"implicit",
"instantiations",
";",
"otherwise",
"we",
"get",
"duplicate",
"symbol",
"errors",
".",
"For",
"Darwin",
"we",
"do",
"not",
"want",
"explicit",
"instantiations",
"to",
"be",
"linkonce",
"."
] | void
maybe_make_one_only (tree decl)
{
if (! flag_weak)
return;
if (!TARGET_WEAK_NOT_IN_ARCHIVE_TOC
|| (! DECL_EXPLICIT_INSTANTIATION (decl)
&& ! DECL_TEMPLATE_SPECIALIZATION (decl)))
{
make_decl_one_only (decl, cxx_comdat_group (decl));
if (TREE_CODE (decl) == VAR_DECL)
{
DECL_COMDAT (decl) = 1;
mark_decl_referenced (decl);
}
}
} | [
"void",
"maybe_make_one_only",
"(",
"tree",
"decl",
")",
"{",
"if",
"(",
"!",
"flag_weak",
")",
"return",
";",
"if",
"(",
"!",
"TARGET_WEAK_NOT_IN_ARCHIVE_TOC",
"||",
"(",
"!",
"DECL_EXPLICIT_INSTANTIATION",
"(",
"decl",
")",
"&&",
"!",
"DECL_TEMPLATE_SPECIALIZATION",
"(",
"decl",
")",
")",
")",
"{",
"make_decl_one_only",
"(",
"decl",
",",
"cxx_comdat_group",
"(",
"decl",
")",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"VAR_DECL",
")",
"{",
"DECL_COMDAT",
"(",
"decl",
")",
"=",
"1",
";",
"mark_decl_referenced",
"(",
"decl",
")",
";",
"}",
"}",
"}"
] | For win32 we also want to put explicit instantiations in
linkonce sections, so that they will be merged with implicit
instantiations; otherwise we get duplicate symbol errors. | [
"For",
"win32",
"we",
"also",
"want",
"to",
"put",
"explicit",
"instantiations",
"in",
"linkonce",
"sections",
"so",
"that",
"they",
"will",
"be",
"merged",
"with",
"implicit",
"instantiations",
";",
"otherwise",
"we",
"get",
"duplicate",
"symbol",
"errors",
"."
] | [
"/* We used to say that this was not necessary on targets that support weak\n symbols, because the implicit instantiations will defer to the explicit\n one. However, that's not actually the case in SVR4; a strong definition\n after a weak one is an error. Also, not making explicit\n instantiations one_only means that we can end up with two copies of\n some template instantiations. */",
"/* We can't set DECL_COMDAT on functions, or cp_finish_file will think\n we can get away with not emitting them if they aren't used. We need\n to for variables so that cp_finish_decl will update their linkage,\n because their DECL_INITIAL may not have been set properly yet. */",
"/* Mark it needed so we don't forget to emit it. */"
] | [
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | vague_linkage_p | bool | bool
vague_linkage_p (tree decl)
{
/* Unfortunately, import_export_decl has not always been called
before the function is processed, so we cannot simply check
DECL_COMDAT. */
return (DECL_COMDAT (decl)
|| (((TREE_CODE (decl) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (decl))
|| (DECL_LANG_SPECIFIC (decl)
&& DECL_TEMPLATE_INSTANTIATION (decl)))
&& TREE_PUBLIC (decl)));
} | /* Returns true iff DECL, a FUNCTION_DECL or VAR_DECL, has vague linkage.
This predicate will give the right answer during parsing of the
function, which other tests may not. */ | Returns true iff DECL, a FUNCTION_DECL or VAR_DECL, has vague linkage.
This predicate will give the right answer during parsing of the
function, which other tests may not. | [
"Returns",
"true",
"iff",
"DECL",
"a",
"FUNCTION_DECL",
"or",
"VAR_DECL",
"has",
"vague",
"linkage",
".",
"This",
"predicate",
"will",
"give",
"the",
"right",
"answer",
"during",
"parsing",
"of",
"the",
"function",
"which",
"other",
"tests",
"may",
"not",
"."
] | bool
vague_linkage_p (tree decl)
{
return (DECL_COMDAT (decl)
|| (((TREE_CODE (decl) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (decl))
|| (DECL_LANG_SPECIFIC (decl)
&& DECL_TEMPLATE_INSTANTIATION (decl)))
&& TREE_PUBLIC (decl)));
} | [
"bool",
"vague_linkage_p",
"(",
"tree",
"decl",
")",
"{",
"return",
"(",
"DECL_COMDAT",
"(",
"decl",
")",
"||",
"(",
"(",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
"&&",
"DECL_DECLARED_INLINE_P",
"(",
"decl",
")",
")",
"||",
"(",
"DECL_LANG_SPECIFIC",
"(",
"decl",
")",
"&&",
"DECL_TEMPLATE_INSTANTIATION",
"(",
"decl",
")",
")",
")",
"&&",
"TREE_PUBLIC",
"(",
"decl",
")",
")",
")",
";",
"}"
] | Returns true iff DECL, a FUNCTION_DECL or VAR_DECL, has vague linkage. | [
"Returns",
"true",
"iff",
"DECL",
"a",
"FUNCTION_DECL",
"or",
"VAR_DECL",
"has",
"vague",
"linkage",
"."
] | [
"/* Unfortunately, import_export_decl has not always been called\n before the function is processed, so we cannot simply check\n DECL_COMDAT. */"
] | [
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | import_export_class | void | static void
import_export_class (tree ctype)
{
/* -1 for imported, 1 for exported. */
int import_export = 0;
/* It only makes sense to call this function at EOF. The reason is
that this function looks at whether or not the first non-inline
non-abstract virtual member function has been defined in this
translation unit. But, we can't possibly know that until we've
seen the entire translation unit. */
gcc_assert (at_eof);
if (CLASSTYPE_INTERFACE_KNOWN (ctype))
return;
/* If MULTIPLE_SYMBOL_SPACES is set and we saw a #pragma interface,
we will have CLASSTYPE_INTERFACE_ONLY set but not
CLASSTYPE_INTERFACE_KNOWN. In that case, we don't want to use this
heuristic because someone will supply a #pragma implementation
elsewhere, and deducing it here would produce a conflict. */
if (CLASSTYPE_INTERFACE_ONLY (ctype))
return;
if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype)))
import_export = -1;
else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype)))
import_export = 1;
else if (CLASSTYPE_IMPLICIT_INSTANTIATION (ctype)
&& !flag_implicit_templates)
/* For a template class, without -fimplicit-templates, check the
repository. If the virtual table is assigned to this
translation unit, then export the class; otherwise, import
it. */
import_export = repo_export_class_p (ctype) ? 1 : -1;
else if (TYPE_POLYMORPHIC_P (ctype))
{
/* The ABI specifies that the virtual table and associated
information are emitted with the key method, if any. */
tree method = CLASSTYPE_KEY_METHOD (ctype);
/* If weak symbol support is not available, then we must be
careful not to emit the vtable when the key function is
inline. An inline function can be defined in multiple
translation units. If we were to emit the vtable in each
translation unit containing a definition, we would get
multiple definition errors at link-time. */
if (method && (flag_weak || ! DECL_DECLARED_INLINE_P (method)))
import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1);
}
/* When MULTIPLE_SYMBOL_SPACES is set, we cannot count on seeing
a definition anywhere else. */
if (MULTIPLE_SYMBOL_SPACES && import_export == -1)
import_export = 0;
/* Allow back ends the chance to overrule the decision. */
if (targetm.cxx.import_export_class)
import_export = targetm.cxx.import_export_class (ctype, import_export);
if (import_export)
{
SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0);
}
} | /* Determine whether or not we want to specifically import or export CTYPE,
using various heuristics. */ | Determine whether or not we want to specifically import or export CTYPE,
using various heuristics. | [
"Determine",
"whether",
"or",
"not",
"we",
"want",
"to",
"specifically",
"import",
"or",
"export",
"CTYPE",
"using",
"various",
"heuristics",
"."
] | static void
import_export_class (tree ctype)
{
int import_export = 0;
gcc_assert (at_eof);
if (CLASSTYPE_INTERFACE_KNOWN (ctype))
return;
if (CLASSTYPE_INTERFACE_ONLY (ctype))
return;
if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype)))
import_export = -1;
else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype)))
import_export = 1;
else if (CLASSTYPE_IMPLICIT_INSTANTIATION (ctype)
&& !flag_implicit_templates)
import_export = repo_export_class_p (ctype) ? 1 : -1;
else if (TYPE_POLYMORPHIC_P (ctype))
{
tree method = CLASSTYPE_KEY_METHOD (ctype);
if (method && (flag_weak || ! DECL_DECLARED_INLINE_P (method)))
import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1);
}
if (MULTIPLE_SYMBOL_SPACES && import_export == -1)
import_export = 0;
if (targetm.cxx.import_export_class)
import_export = targetm.cxx.import_export_class (ctype, import_export);
if (import_export)
{
SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0);
}
} | [
"static",
"void",
"import_export_class",
"(",
"tree",
"ctype",
")",
"{",
"int",
"import_export",
"=",
"0",
";",
"gcc_assert",
"(",
"at_eof",
")",
";",
"if",
"(",
"CLASSTYPE_INTERFACE_KNOWN",
"(",
"ctype",
")",
")",
"return",
";",
"if",
"(",
"CLASSTYPE_INTERFACE_ONLY",
"(",
"ctype",
")",
")",
"return",
";",
"if",
"(",
"lookup_attribute",
"(",
"\"",
"\"",
",",
"TYPE_ATTRIBUTES",
"(",
"ctype",
")",
")",
")",
"import_export",
"=",
"-1",
";",
"else",
"if",
"(",
"lookup_attribute",
"(",
"\"",
"\"",
",",
"TYPE_ATTRIBUTES",
"(",
"ctype",
")",
")",
")",
"import_export",
"=",
"1",
";",
"else",
"if",
"(",
"CLASSTYPE_IMPLICIT_INSTANTIATION",
"(",
"ctype",
")",
"&&",
"!",
"flag_implicit_templates",
")",
"import_export",
"=",
"repo_export_class_p",
"(",
"ctype",
")",
"?",
"1",
":",
"-1",
";",
"else",
"if",
"(",
"TYPE_POLYMORPHIC_P",
"(",
"ctype",
")",
")",
"{",
"tree",
"method",
"=",
"CLASSTYPE_KEY_METHOD",
"(",
"ctype",
")",
";",
"if",
"(",
"method",
"&&",
"(",
"flag_weak",
"||",
"!",
"DECL_DECLARED_INLINE_P",
"(",
"method",
")",
")",
")",
"import_export",
"=",
"(",
"DECL_REALLY_EXTERN",
"(",
"method",
")",
"?",
"-1",
":",
"1",
")",
";",
"}",
"if",
"(",
"MULTIPLE_SYMBOL_SPACES",
"&&",
"import_export",
"==",
"-1",
")",
"import_export",
"=",
"0",
";",
"if",
"(",
"targetm",
".",
"cxx",
".",
"import_export_class",
")",
"import_export",
"=",
"targetm",
".",
"cxx",
".",
"import_export_class",
"(",
"ctype",
",",
"import_export",
")",
";",
"if",
"(",
"import_export",
")",
"{",
"SET_CLASSTYPE_INTERFACE_KNOWN",
"(",
"ctype",
")",
";",
"CLASSTYPE_INTERFACE_ONLY",
"(",
"ctype",
")",
"=",
"(",
"import_export",
"<",
"0",
")",
";",
"}",
"}"
] | Determine whether or not we want to specifically import or export CTYPE,
using various heuristics. | [
"Determine",
"whether",
"or",
"not",
"we",
"want",
"to",
"specifically",
"import",
"or",
"export",
"CTYPE",
"using",
"various",
"heuristics",
"."
] | [
"/* -1 for imported, 1 for exported. */",
"/* It only makes sense to call this function at EOF. The reason is\n that this function looks at whether or not the first non-inline\n non-abstract virtual member function has been defined in this\n translation unit. But, we can't possibly know that until we've\n seen the entire translation unit. */",
"/* If MULTIPLE_SYMBOL_SPACES is set and we saw a #pragma interface,\n we will have CLASSTYPE_INTERFACE_ONLY set but not\n CLASSTYPE_INTERFACE_KNOWN. In that case, we don't want to use this\n heuristic because someone will supply a #pragma implementation\n elsewhere, and deducing it here would produce a conflict. */",
"/* For a template class, without -fimplicit-templates, check the\n repository. If the virtual table is assigned to this\n translation unit, then export the class; otherwise, import\n it. */",
"/* The ABI specifies that the virtual table and associated\n\t information are emitted with the key method, if any. */",
"/* If weak symbol support is not available, then we must be\n\t careful not to emit the vtable when the key function is\n\t inline. An inline function can be defined in multiple\n\t translation units. If we were to emit the vtable in each\n\t translation unit containing a definition, we would get\n\t multiple definition errors at link-time. */",
"/* When MULTIPLE_SYMBOL_SPACES is set, we cannot count on seeing\n a definition anywhere else. */",
"/* Allow back ends the chance to overrule the decision. */"
] | [
{
"param": "ctype",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "ctype",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | var_finalized_p | bool | static bool
var_finalized_p (tree var)
{
return varpool_node (var)->finalized;
} | /* Return true if VAR has already been provided to the back end; in that
case VAR should not be modified further by the front end. */ | Return true if VAR has already been provided to the back end; in that
case VAR should not be modified further by the front end. | [
"Return",
"true",
"if",
"VAR",
"has",
"already",
"been",
"provided",
"to",
"the",
"back",
"end",
";",
"in",
"that",
"case",
"VAR",
"should",
"not",
"be",
"modified",
"further",
"by",
"the",
"front",
"end",
"."
] | static bool
var_finalized_p (tree var)
{
return varpool_node (var)->finalized;
} | [
"static",
"bool",
"var_finalized_p",
"(",
"tree",
"var",
")",
"{",
"return",
"varpool_node",
"(",
"var",
")",
"->",
"finalized",
";",
"}"
] | Return true if VAR has already been provided to the back end; in that
case VAR should not be modified further by the front end. | [
"Return",
"true",
"if",
"VAR",
"has",
"already",
"been",
"provided",
"to",
"the",
"back",
"end",
";",
"in",
"that",
"case",
"VAR",
"should",
"not",
"be",
"modified",
"further",
"by",
"the",
"front",
"end",
"."
] | [] | [
{
"param": "var",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "var",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | mark_needed | void | void
mark_needed (tree decl)
{
/* It's possible that we no longer need to set
TREE_SYMBOL_REFERENCED here directly, but doing so is
harmless. */
TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)) = 1;
mark_decl_referenced (decl);
} | /* DECL is a VAR_DECL or FUNCTION_DECL which, for whatever reason,
must be emitted in this translation unit. Mark it as such. */ | DECL is a VAR_DECL or FUNCTION_DECL which, for whatever reason,
must be emitted in this translation unit. Mark it as such. | [
"DECL",
"is",
"a",
"VAR_DECL",
"or",
"FUNCTION_DECL",
"which",
"for",
"whatever",
"reason",
"must",
"be",
"emitted",
"in",
"this",
"translation",
"unit",
".",
"Mark",
"it",
"as",
"such",
"."
] | void
mark_needed (tree decl)
{
TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)) = 1;
mark_decl_referenced (decl);
} | [
"void",
"mark_needed",
"(",
"tree",
"decl",
")",
"{",
"TREE_SYMBOL_REFERENCED",
"(",
"DECL_ASSEMBLER_NAME",
"(",
"decl",
")",
")",
"=",
"1",
";",
"mark_decl_referenced",
"(",
"decl",
")",
";",
"}"
] | DECL is a VAR_DECL or FUNCTION_DECL which, for whatever reason,
must be emitted in this translation unit. | [
"DECL",
"is",
"a",
"VAR_DECL",
"or",
"FUNCTION_DECL",
"which",
"for",
"whatever",
"reason",
"must",
"be",
"emitted",
"in",
"this",
"translation",
"unit",
"."
] | [
"/* It's possible that we no longer need to set\n TREE_SYMBOL_REFERENCED here directly, but doing so is\n harmless. */"
] | [
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | decl_needed_p | bool | bool
decl_needed_p (tree decl)
{
gcc_assert (TREE_CODE (decl) == VAR_DECL
|| TREE_CODE (decl) == FUNCTION_DECL);
/* This function should only be called at the end of the translation
unit. We cannot be sure of whether or not something will be
COMDAT until that point. */
gcc_assert (at_eof);
/* All entities with external linkage that are not COMDAT should be
emitted; they may be referred to from other object files. */
if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
return true;
/* If this entity was used, let the back end see it; it will decide
whether or not to emit it into the object file. */
if (TREE_USED (decl)
|| (DECL_ASSEMBLER_NAME_SET_P (decl)
&& TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
return true;
/* Functions marked "dllexport" must be emitted so that they are
visible to other DLLs. */
if (flag_keep_inline_dllexport
&& lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
return true;
/* Otherwise, DECL does not need to be emitted -- yet. A subsequent
reference to DECL might cause it to be emitted later. */
return false;
} | /* DECL is either a FUNCTION_DECL or a VAR_DECL. This function
returns true if a definition of this entity should be provided in
this object file. Callers use this function to determine whether
or not to let the back end know that a definition of DECL is
available in this translation unit. */ | DECL is either a FUNCTION_DECL or a VAR_DECL. This function
returns true if a definition of this entity should be provided in
this object file. Callers use this function to determine whether
or not to let the back end know that a definition of DECL is
available in this translation unit. | [
"DECL",
"is",
"either",
"a",
"FUNCTION_DECL",
"or",
"a",
"VAR_DECL",
".",
"This",
"function",
"returns",
"true",
"if",
"a",
"definition",
"of",
"this",
"entity",
"should",
"be",
"provided",
"in",
"this",
"object",
"file",
".",
"Callers",
"use",
"this",
"function",
"to",
"determine",
"whether",
"or",
"not",
"to",
"let",
"the",
"back",
"end",
"know",
"that",
"a",
"definition",
"of",
"DECL",
"is",
"available",
"in",
"this",
"translation",
"unit",
"."
] | bool
decl_needed_p (tree decl)
{
gcc_assert (TREE_CODE (decl) == VAR_DECL
|| TREE_CODE (decl) == FUNCTION_DECL);
gcc_assert (at_eof);
if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
return true;
if (TREE_USED (decl)
|| (DECL_ASSEMBLER_NAME_SET_P (decl)
&& TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
return true;
if (flag_keep_inline_dllexport
&& lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
return true;
return false;
} | [
"bool",
"decl_needed_p",
"(",
"tree",
"decl",
")",
"{",
"gcc_assert",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"VAR_DECL",
"||",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
")",
";",
"gcc_assert",
"(",
"at_eof",
")",
";",
"if",
"(",
"TREE_PUBLIC",
"(",
"decl",
")",
"&&",
"!",
"DECL_COMDAT",
"(",
"decl",
")",
")",
"return",
"true",
";",
"if",
"(",
"TREE_USED",
"(",
"decl",
")",
"||",
"(",
"DECL_ASSEMBLER_NAME_SET_P",
"(",
"decl",
")",
"&&",
"TREE_SYMBOL_REFERENCED",
"(",
"DECL_ASSEMBLER_NAME",
"(",
"decl",
")",
")",
")",
")",
"return",
"true",
";",
"if",
"(",
"flag_keep_inline_dllexport",
"&&",
"lookup_attribute",
"(",
"\"",
"\"",
",",
"DECL_ATTRIBUTES",
"(",
"decl",
")",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}"
] | DECL is either a FUNCTION_DECL or a VAR_DECL. | [
"DECL",
"is",
"either",
"a",
"FUNCTION_DECL",
"or",
"a",
"VAR_DECL",
"."
] | [
"/* This function should only be called at the end of the translation\n unit. We cannot be sure of whether or not something will be\n COMDAT until that point. */",
"/* All entities with external linkage that are not COMDAT should be\n emitted; they may be referred to from other object files. */",
"/* If this entity was used, let the back end see it; it will decide\n whether or not to emit it into the object file. */",
"/* Functions marked \"dllexport\" must be emitted so that they are\n visible to other DLLs. */",
"/* Otherwise, DECL does not need to be emitted -- yet. A subsequent\n reference to DECL might cause it to be emitted later. */"
] | [
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | maybe_emit_vtables | bool | static bool
maybe_emit_vtables (tree ctype)
{
tree vtbl;
tree primary_vtbl;
int needed = 0;
struct varpool_node *current = NULL, *last = NULL, *first = NULL;
/* If the vtables for this class have already been emitted there is
nothing more to do. */
primary_vtbl = CLASSTYPE_VTABLES (ctype);
if (var_finalized_p (primary_vtbl))
return false;
/* Ignore dummy vtables made by get_vtable_decl. */
if (TREE_TYPE (primary_vtbl) == void_type_node)
return false;
/* On some targets, we cannot determine the key method until the end
of the translation unit -- which is when this function is
called. */
if (!targetm.cxx.key_method_may_be_inline ())
determine_key_method (ctype);
/* See if any of the vtables are needed. */
for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = DECL_CHAIN (vtbl))
{
import_export_decl (vtbl);
if (DECL_NOT_REALLY_EXTERN (vtbl) && decl_needed_p (vtbl))
needed = 1;
}
if (!needed)
{
/* If the references to this class' vtables are optimized away,
still emit the appropriate debugging information. See
dfs_debug_mark. */
if (DECL_COMDAT (primary_vtbl)
&& CLASSTYPE_DEBUG_REQUESTED (ctype))
note_debug_info_needed (ctype);
return false;
}
/* The ABI requires that we emit all of the vtables if we emit any
of them. */
for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = DECL_CHAIN (vtbl))
{
/* Mark entities references from the virtual table as used. */
mark_vtable_entries (vtbl);
if (TREE_TYPE (DECL_INITIAL (vtbl)) == 0)
{
VEC(tree,gc)* cleanups = NULL;
tree expr = store_init_value (vtbl, DECL_INITIAL (vtbl), &cleanups,
LOOKUP_NORMAL);
/* It had better be all done at compile-time. */
gcc_assert (!expr && !cleanups);
}
/* Write it out. */
DECL_EXTERNAL (vtbl) = 0;
rest_of_decl_compilation (vtbl, 1, 1);
/* Because we're only doing syntax-checking, we'll never end up
actually marking the variable as written. */
if (flag_syntax_only)
TREE_ASM_WRITTEN (vtbl) = 1;
else if (DECL_COMDAT (vtbl))
{
current = varpool_node (vtbl);
if (last)
last->same_comdat_group = current;
last = current;
if (!first)
first = current;
}
}
if (first != last)
last->same_comdat_group = first;
/* Since we're writing out the vtable here, also write the debug
info. */
note_debug_info_needed (ctype);
return true;
} | /* If necessary, write out the vtables for the dynamic class CTYPE.
Returns true if any vtables were emitted. */ | If necessary, write out the vtables for the dynamic class CTYPE.
Returns true if any vtables were emitted. | [
"If",
"necessary",
"write",
"out",
"the",
"vtables",
"for",
"the",
"dynamic",
"class",
"CTYPE",
".",
"Returns",
"true",
"if",
"any",
"vtables",
"were",
"emitted",
"."
] | static bool
maybe_emit_vtables (tree ctype)
{
tree vtbl;
tree primary_vtbl;
int needed = 0;
struct varpool_node *current = NULL, *last = NULL, *first = NULL;
primary_vtbl = CLASSTYPE_VTABLES (ctype);
if (var_finalized_p (primary_vtbl))
return false;
if (TREE_TYPE (primary_vtbl) == void_type_node)
return false;
if (!targetm.cxx.key_method_may_be_inline ())
determine_key_method (ctype);
for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = DECL_CHAIN (vtbl))
{
import_export_decl (vtbl);
if (DECL_NOT_REALLY_EXTERN (vtbl) && decl_needed_p (vtbl))
needed = 1;
}
if (!needed)
{
if (DECL_COMDAT (primary_vtbl)
&& CLASSTYPE_DEBUG_REQUESTED (ctype))
note_debug_info_needed (ctype);
return false;
}
for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = DECL_CHAIN (vtbl))
{
mark_vtable_entries (vtbl);
if (TREE_TYPE (DECL_INITIAL (vtbl)) == 0)
{
VEC(tree,gc)* cleanups = NULL;
tree expr = store_init_value (vtbl, DECL_INITIAL (vtbl), &cleanups,
LOOKUP_NORMAL);
gcc_assert (!expr && !cleanups);
}
DECL_EXTERNAL (vtbl) = 0;
rest_of_decl_compilation (vtbl, 1, 1);
if (flag_syntax_only)
TREE_ASM_WRITTEN (vtbl) = 1;
else if (DECL_COMDAT (vtbl))
{
current = varpool_node (vtbl);
if (last)
last->same_comdat_group = current;
last = current;
if (!first)
first = current;
}
}
if (first != last)
last->same_comdat_group = first;
note_debug_info_needed (ctype);
return true;
} | [
"static",
"bool",
"maybe_emit_vtables",
"(",
"tree",
"ctype",
")",
"{",
"tree",
"vtbl",
";",
"tree",
"primary_vtbl",
";",
"int",
"needed",
"=",
"0",
";",
"struct",
"varpool_node",
"*",
"current",
"=",
"NULL",
",",
"*",
"last",
"=",
"NULL",
",",
"*",
"first",
"=",
"NULL",
";",
"primary_vtbl",
"=",
"CLASSTYPE_VTABLES",
"(",
"ctype",
")",
";",
"if",
"(",
"var_finalized_p",
"(",
"primary_vtbl",
")",
")",
"return",
"false",
";",
"if",
"(",
"TREE_TYPE",
"(",
"primary_vtbl",
")",
"==",
"void_type_node",
")",
"return",
"false",
";",
"if",
"(",
"!",
"targetm",
".",
"cxx",
".",
"key_method_may_be_inline",
"(",
")",
")",
"determine_key_method",
"(",
"ctype",
")",
";",
"for",
"(",
"vtbl",
"=",
"CLASSTYPE_VTABLES",
"(",
"ctype",
")",
";",
"vtbl",
";",
"vtbl",
"=",
"DECL_CHAIN",
"(",
"vtbl",
")",
")",
"{",
"import_export_decl",
"(",
"vtbl",
")",
";",
"if",
"(",
"DECL_NOT_REALLY_EXTERN",
"(",
"vtbl",
")",
"&&",
"decl_needed_p",
"(",
"vtbl",
")",
")",
"needed",
"=",
"1",
";",
"}",
"if",
"(",
"!",
"needed",
")",
"{",
"if",
"(",
"DECL_COMDAT",
"(",
"primary_vtbl",
")",
"&&",
"CLASSTYPE_DEBUG_REQUESTED",
"(",
"ctype",
")",
")",
"note_debug_info_needed",
"(",
"ctype",
")",
";",
"return",
"false",
";",
"}",
"for",
"(",
"vtbl",
"=",
"CLASSTYPE_VTABLES",
"(",
"ctype",
")",
";",
"vtbl",
";",
"vtbl",
"=",
"DECL_CHAIN",
"(",
"vtbl",
")",
")",
"{",
"mark_vtable_entries",
"(",
"vtbl",
")",
";",
"if",
"(",
"TREE_TYPE",
"(",
"DECL_INITIAL",
"(",
"vtbl",
")",
")",
"==",
"0",
")",
"{",
"VEC",
"(",
"tree",
",",
"gc",
")",
"*",
"cleanups",
"=",
"NULL",
";",
"tree",
"expr",
"=",
"store_init_value",
"(",
"vtbl",
",",
"DECL_INITIAL",
"(",
"vtbl",
")",
",",
"&",
"cleanups",
",",
"LOOKUP_NORMAL",
")",
";",
"gcc_assert",
"(",
"!",
"expr",
"&&",
"!",
"cleanups",
")",
";",
"}",
"DECL_EXTERNAL",
"(",
"vtbl",
")",
"=",
"0",
";",
"rest_of_decl_compilation",
"(",
"vtbl",
",",
"1",
",",
"1",
")",
";",
"if",
"(",
"flag_syntax_only",
")",
"TREE_ASM_WRITTEN",
"(",
"vtbl",
")",
"=",
"1",
";",
"else",
"if",
"(",
"DECL_COMDAT",
"(",
"vtbl",
")",
")",
"{",
"current",
"=",
"varpool_node",
"(",
"vtbl",
")",
";",
"if",
"(",
"last",
")",
"last",
"->",
"same_comdat_group",
"=",
"current",
";",
"last",
"=",
"current",
";",
"if",
"(",
"!",
"first",
")",
"first",
"=",
"current",
";",
"}",
"}",
"if",
"(",
"first",
"!=",
"last",
")",
"last",
"->",
"same_comdat_group",
"=",
"first",
";",
"note_debug_info_needed",
"(",
"ctype",
")",
";",
"return",
"true",
";",
"}"
] | If necessary, write out the vtables for the dynamic class CTYPE. | [
"If",
"necessary",
"write",
"out",
"the",
"vtables",
"for",
"the",
"dynamic",
"class",
"CTYPE",
"."
] | [
"/* If the vtables for this class have already been emitted there is\n nothing more to do. */",
"/* Ignore dummy vtables made by get_vtable_decl. */",
"/* On some targets, we cannot determine the key method until the end\n of the translation unit -- which is when this function is\n called. */",
"/* See if any of the vtables are needed. */",
"/* If the references to this class' vtables are optimized away,\n\t still emit the appropriate debugging information. See\n\t dfs_debug_mark. */",
"/* The ABI requires that we emit all of the vtables if we emit any\n of them. */",
"/* Mark entities references from the virtual table as used. */",
"/* It had better be all done at compile-time. */",
"/* Write it out. */",
"/* Because we're only doing syntax-checking, we'll never end up\n\t actually marking the variable as written. */",
"/* Since we're writing out the vtable here, also write the debug\n info. */"
] | [
{
"param": "ctype",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "ctype",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | type_visibility | int | static int
type_visibility (tree type)
{
int vis = VISIBILITY_DEFAULT;
cp_walk_tree_without_duplicates (&type, min_vis_r, &vis);
return vis;
} | /* Returns the visibility of TYPE, which is the minimum visibility of its
component types. */ | Returns the visibility of TYPE, which is the minimum visibility of its
component types. | [
"Returns",
"the",
"visibility",
"of",
"TYPE",
"which",
"is",
"the",
"minimum",
"visibility",
"of",
"its",
"component",
"types",
"."
] | static int
type_visibility (tree type)
{
int vis = VISIBILITY_DEFAULT;
cp_walk_tree_without_duplicates (&type, min_vis_r, &vis);
return vis;
} | [
"static",
"int",
"type_visibility",
"(",
"tree",
"type",
")",
"{",
"int",
"vis",
"=",
"VISIBILITY_DEFAULT",
";",
"cp_walk_tree_without_duplicates",
"(",
"&",
"type",
",",
"min_vis_r",
",",
"&",
"vis",
")",
";",
"return",
"vis",
";",
"}"
] | Returns the visibility of TYPE, which is the minimum visibility of its
component types. | [
"Returns",
"the",
"visibility",
"of",
"TYPE",
"which",
"is",
"the",
"minimum",
"visibility",
"of",
"its",
"component",
"types",
"."
] | [] | [
{
"param": "type",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "type",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | constrain_visibility | void | static void
constrain_visibility (tree decl, int visibility, bool tmpl)
{
if (visibility == VISIBILITY_ANON)
{
/* extern "C" declarations aren't affected by the anonymous
namespace. */
if (!DECL_EXTERN_C_P (decl))
{
TREE_PUBLIC (decl) = 0;
DECL_WEAK (decl) = 0;
DECL_COMMON (decl) = 0;
DECL_COMDAT_GROUP (decl) = NULL_TREE;
DECL_INTERFACE_KNOWN (decl) = 1;
if (DECL_LANG_SPECIFIC (decl))
DECL_NOT_REALLY_EXTERN (decl) = 1;
}
}
else if (visibility > DECL_VISIBILITY (decl)
&& (tmpl || !DECL_VISIBILITY_SPECIFIED (decl)))
{
DECL_VISIBILITY (decl) = (enum symbol_visibility) visibility;
/* This visibility was not specified. */
DECL_VISIBILITY_SPECIFIED (decl) = false;
}
} | /* Limit the visibility of DECL to VISIBILITY, if not explicitly
specified (or if VISIBILITY is static). If TMPL is true, this
constraint is for a template argument, and takes precedence
over explicitly-specified visibility on the template. */ | Limit the visibility of DECL to VISIBILITY, if not explicitly
specified (or if VISIBILITY is static). If TMPL is true, this
constraint is for a template argument, and takes precedence
over explicitly-specified visibility on the template. | [
"Limit",
"the",
"visibility",
"of",
"DECL",
"to",
"VISIBILITY",
"if",
"not",
"explicitly",
"specified",
"(",
"or",
"if",
"VISIBILITY",
"is",
"static",
")",
".",
"If",
"TMPL",
"is",
"true",
"this",
"constraint",
"is",
"for",
"a",
"template",
"argument",
"and",
"takes",
"precedence",
"over",
"explicitly",
"-",
"specified",
"visibility",
"on",
"the",
"template",
"."
] | static void
constrain_visibility (tree decl, int visibility, bool tmpl)
{
if (visibility == VISIBILITY_ANON)
{
if (!DECL_EXTERN_C_P (decl))
{
TREE_PUBLIC (decl) = 0;
DECL_WEAK (decl) = 0;
DECL_COMMON (decl) = 0;
DECL_COMDAT_GROUP (decl) = NULL_TREE;
DECL_INTERFACE_KNOWN (decl) = 1;
if (DECL_LANG_SPECIFIC (decl))
DECL_NOT_REALLY_EXTERN (decl) = 1;
}
}
else if (visibility > DECL_VISIBILITY (decl)
&& (tmpl || !DECL_VISIBILITY_SPECIFIED (decl)))
{
DECL_VISIBILITY (decl) = (enum symbol_visibility) visibility;
DECL_VISIBILITY_SPECIFIED (decl) = false;
}
} | [
"static",
"void",
"constrain_visibility",
"(",
"tree",
"decl",
",",
"int",
"visibility",
",",
"bool",
"tmpl",
")",
"{",
"if",
"(",
"visibility",
"==",
"VISIBILITY_ANON",
")",
"{",
"if",
"(",
"!",
"DECL_EXTERN_C_P",
"(",
"decl",
")",
")",
"{",
"TREE_PUBLIC",
"(",
"decl",
")",
"=",
"0",
";",
"DECL_WEAK",
"(",
"decl",
")",
"=",
"0",
";",
"DECL_COMMON",
"(",
"decl",
")",
"=",
"0",
";",
"DECL_COMDAT_GROUP",
"(",
"decl",
")",
"=",
"NULL_TREE",
";",
"DECL_INTERFACE_KNOWN",
"(",
"decl",
")",
"=",
"1",
";",
"if",
"(",
"DECL_LANG_SPECIFIC",
"(",
"decl",
")",
")",
"DECL_NOT_REALLY_EXTERN",
"(",
"decl",
")",
"=",
"1",
";",
"}",
"}",
"else",
"if",
"(",
"visibility",
">",
"DECL_VISIBILITY",
"(",
"decl",
")",
"&&",
"(",
"tmpl",
"||",
"!",
"DECL_VISIBILITY_SPECIFIED",
"(",
"decl",
")",
")",
")",
"{",
"DECL_VISIBILITY",
"(",
"decl",
")",
"=",
"(",
"enum",
"symbol_visibility",
")",
"visibility",
";",
"DECL_VISIBILITY_SPECIFIED",
"(",
"decl",
")",
"=",
"false",
";",
"}",
"}"
] | Limit the visibility of DECL to VISIBILITY, if not explicitly
specified (or if VISIBILITY is static). | [
"Limit",
"the",
"visibility",
"of",
"DECL",
"to",
"VISIBILITY",
"if",
"not",
"explicitly",
"specified",
"(",
"or",
"if",
"VISIBILITY",
"is",
"static",
")",
"."
] | [
"/* extern \"C\" declarations aren't affected by the anonymous\n\t namespace. */",
"/* This visibility was not specified. */"
] | [
{
"param": "decl",
"type": "tree"
},
{
"param": "visibility",
"type": "int"
},
{
"param": "tmpl",
"type": "bool"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "visibility",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "tmpl",
"type": "bool",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | constrain_visibility_for_template | void | static void
constrain_visibility_for_template (tree decl, tree targs)
{
/* If this is a template instantiation, check the innermost
template args for visibility constraints. The outer template
args are covered by the class check. */
tree args = INNERMOST_TEMPLATE_ARGS (targs);
int i;
for (i = TREE_VEC_LENGTH (args); i > 0; --i)
{
int vis = 0;
tree arg = TREE_VEC_ELT (args, i-1);
if (TYPE_P (arg))
vis = type_visibility (arg);
else if (TREE_TYPE (arg) && POINTER_TYPE_P (TREE_TYPE (arg)))
{
STRIP_NOPS (arg);
if (TREE_CODE (arg) == ADDR_EXPR)
arg = TREE_OPERAND (arg, 0);
if (TREE_CODE (arg) == VAR_DECL
|| TREE_CODE (arg) == FUNCTION_DECL)
{
if (! TREE_PUBLIC (arg))
vis = VISIBILITY_ANON;
else
vis = DECL_VISIBILITY (arg);
}
}
if (vis)
constrain_visibility (decl, vis, true);
}
} | /* Constrain the visibility of DECL based on the visibility of its template
arguments. */ | Constrain the visibility of DECL based on the visibility of its template
arguments. | [
"Constrain",
"the",
"visibility",
"of",
"DECL",
"based",
"on",
"the",
"visibility",
"of",
"its",
"template",
"arguments",
"."
] | static void
constrain_visibility_for_template (tree decl, tree targs)
{
tree args = INNERMOST_TEMPLATE_ARGS (targs);
int i;
for (i = TREE_VEC_LENGTH (args); i > 0; --i)
{
int vis = 0;
tree arg = TREE_VEC_ELT (args, i-1);
if (TYPE_P (arg))
vis = type_visibility (arg);
else if (TREE_TYPE (arg) && POINTER_TYPE_P (TREE_TYPE (arg)))
{
STRIP_NOPS (arg);
if (TREE_CODE (arg) == ADDR_EXPR)
arg = TREE_OPERAND (arg, 0);
if (TREE_CODE (arg) == VAR_DECL
|| TREE_CODE (arg) == FUNCTION_DECL)
{
if (! TREE_PUBLIC (arg))
vis = VISIBILITY_ANON;
else
vis = DECL_VISIBILITY (arg);
}
}
if (vis)
constrain_visibility (decl, vis, true);
}
} | [
"static",
"void",
"constrain_visibility_for_template",
"(",
"tree",
"decl",
",",
"tree",
"targs",
")",
"{",
"tree",
"args",
"=",
"INNERMOST_TEMPLATE_ARGS",
"(",
"targs",
")",
";",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"TREE_VEC_LENGTH",
"(",
"args",
")",
";",
"i",
">",
"0",
";",
"--",
"i",
")",
"{",
"int",
"vis",
"=",
"0",
";",
"tree",
"arg",
"=",
"TREE_VEC_ELT",
"(",
"args",
",",
"i",
"-",
"1",
")",
";",
"if",
"(",
"TYPE_P",
"(",
"arg",
")",
")",
"vis",
"=",
"type_visibility",
"(",
"arg",
")",
";",
"else",
"if",
"(",
"TREE_TYPE",
"(",
"arg",
")",
"&&",
"POINTER_TYPE_P",
"(",
"TREE_TYPE",
"(",
"arg",
")",
")",
")",
"{",
"STRIP_NOPS",
"(",
"arg",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"arg",
")",
"==",
"ADDR_EXPR",
")",
"arg",
"=",
"TREE_OPERAND",
"(",
"arg",
",",
"0",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"arg",
")",
"==",
"VAR_DECL",
"||",
"TREE_CODE",
"(",
"arg",
")",
"==",
"FUNCTION_DECL",
")",
"{",
"if",
"(",
"!",
"TREE_PUBLIC",
"(",
"arg",
")",
")",
"vis",
"=",
"VISIBILITY_ANON",
";",
"else",
"vis",
"=",
"DECL_VISIBILITY",
"(",
"arg",
")",
";",
"}",
"}",
"if",
"(",
"vis",
")",
"constrain_visibility",
"(",
"decl",
",",
"vis",
",",
"true",
")",
";",
"}",
"}"
] | Constrain the visibility of DECL based on the visibility of its template
arguments. | [
"Constrain",
"the",
"visibility",
"of",
"DECL",
"based",
"on",
"the",
"visibility",
"of",
"its",
"template",
"arguments",
"."
] | [
"/* If this is a template instantiation, check the innermost\n template args for visibility constraints. The outer template\n args are covered by the class check. */"
] | [
{
"param": "decl",
"type": "tree"
},
{
"param": "targs",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "targs",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | determine_visibility | void | void
determine_visibility (tree decl)
{
tree class_type = NULL_TREE;
bool use_template;
bool orig_visibility_specified;
enum symbol_visibility orig_visibility;
/* Remember that all decls get VISIBILITY_DEFAULT when built. */
/* Only relevant for names with external linkage. */
if (!TREE_PUBLIC (decl))
return;
/* Cloned constructors and destructors get the same visibility as
the underlying function. That should be set up in
maybe_clone_body. */
gcc_assert (!DECL_CLONED_FUNCTION_P (decl));
orig_visibility_specified = DECL_VISIBILITY_SPECIFIED (decl);
orig_visibility = DECL_VISIBILITY (decl);
if (TREE_CODE (decl) == TYPE_DECL)
{
if (CLASS_TYPE_P (TREE_TYPE (decl)))
use_template = CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl));
else if (TYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
use_template = 1;
else
use_template = 0;
}
else if (DECL_LANG_SPECIFIC (decl))
use_template = DECL_USE_TEMPLATE (decl);
else
use_template = 0;
/* If DECL is a member of a class, visibility specifiers on the
class can influence the visibility of the DECL. */
if (DECL_CLASS_SCOPE_P (decl))
class_type = DECL_CONTEXT (decl);
else
{
/* Not a class member. */
/* Virtual tables have DECL_CONTEXT set to their associated class,
so they are automatically handled above. */
gcc_assert (TREE_CODE (decl) != VAR_DECL
|| !DECL_VTABLE_OR_VTT_P (decl));
if (DECL_FUNCTION_SCOPE_P (decl) && ! DECL_VISIBILITY_SPECIFIED (decl))
{
/* Local statics and classes get the visibility of their
containing function by default, except that
-fvisibility-inlines-hidden doesn't affect them. */
tree fn = DECL_CONTEXT (decl);
if (DECL_VISIBILITY_SPECIFIED (fn))
{
DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn);
DECL_VISIBILITY_SPECIFIED (decl) =
DECL_VISIBILITY_SPECIFIED (fn);
}
else
{
if (DECL_CLASS_SCOPE_P (fn))
determine_visibility_from_class (decl, DECL_CONTEXT (fn));
else if (determine_hidden_inline (fn))
{
DECL_VISIBILITY (decl) = default_visibility;
DECL_VISIBILITY_SPECIFIED (decl) =
visibility_options.inpragma;
}
else
{
DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn);
DECL_VISIBILITY_SPECIFIED (decl) =
DECL_VISIBILITY_SPECIFIED (fn);
}
}
/* Local classes in templates have CLASSTYPE_USE_TEMPLATE set,
but have no TEMPLATE_INFO, so don't try to check it. */
use_template = 0;
}
else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl)
&& flag_visibility_ms_compat)
{
/* Under -fvisibility-ms-compat, types are visible by default,
even though their contents aren't. */
tree underlying_type = TREE_TYPE (DECL_NAME (decl));
int underlying_vis = type_visibility (underlying_type);
if (underlying_vis == VISIBILITY_ANON
|| (CLASS_TYPE_P (underlying_type)
&& CLASSTYPE_VISIBILITY_SPECIFIED (underlying_type)))
constrain_visibility (decl, underlying_vis, false);
else
DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
}
else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl))
{
/* tinfo visibility is based on the type it's for. */
constrain_visibility
(decl, type_visibility (TREE_TYPE (DECL_NAME (decl))), false);
/* Give the target a chance to override the visibility associated
with DECL. */
if (TREE_PUBLIC (decl)
&& !DECL_REALLY_EXTERN (decl)
&& CLASS_TYPE_P (TREE_TYPE (DECL_NAME (decl)))
&& !CLASSTYPE_VISIBILITY_SPECIFIED (TREE_TYPE (DECL_NAME (decl))))
targetm.cxx.determine_class_data_visibility (decl);
}
else if (use_template)
/* Template instantiations and specializations get visibility based
on their template unless they override it with an attribute. */;
else if (! DECL_VISIBILITY_SPECIFIED (decl))
{
if (determine_hidden_inline (decl))
DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
else
{
/* Set default visibility to whatever the user supplied with
#pragma GCC visibility or a namespace visibility attribute. */
DECL_VISIBILITY (decl) = default_visibility;
DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
}
}
}
if (use_template)
{
/* If the specialization doesn't specify visibility, use the
visibility from the template. */
tree tinfo = (TREE_CODE (decl) == TYPE_DECL
? TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
: DECL_TEMPLATE_INFO (decl));
tree args = TI_ARGS (tinfo);
tree attribs = (TREE_CODE (decl) == TYPE_DECL
? TYPE_ATTRIBUTES (TREE_TYPE (decl))
: DECL_ATTRIBUTES (decl));
if (args != error_mark_node
/* Template argument visibility outweighs #pragma or namespace
visibility, but not an explicit attribute. */
&& !lookup_attribute ("visibility", attribs))
{
int depth = TMPL_ARGS_DEPTH (args);
tree pattern = DECL_TEMPLATE_RESULT (TI_TEMPLATE (tinfo));
if (!DECL_VISIBILITY_SPECIFIED (decl))
{
if (!DECL_VISIBILITY_SPECIFIED (pattern)
&& determine_hidden_inline (decl))
DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
else
{
DECL_VISIBILITY (decl) = DECL_VISIBILITY (pattern);
DECL_VISIBILITY_SPECIFIED (decl)
= DECL_VISIBILITY_SPECIFIED (pattern);
}
}
/* FIXME should TMPL_ARGS_DEPTH really return 1 for null input? */
if (args && depth > template_class_depth (class_type))
/* Limit visibility based on its template arguments. */
constrain_visibility_for_template (decl, args);
}
}
if (class_type)
determine_visibility_from_class (decl, class_type);
if (decl_anon_ns_mem_p (decl))
/* Names in an anonymous namespace get internal linkage.
This might change once we implement export. */
constrain_visibility (decl, VISIBILITY_ANON, false);
else if (TREE_CODE (decl) != TYPE_DECL)
{
/* Propagate anonymity from type to decl. */
int tvis = type_visibility (TREE_TYPE (decl));
if (tvis == VISIBILITY_ANON
|| ! DECL_VISIBILITY_SPECIFIED (decl))
constrain_visibility (decl, tvis, false);
}
else if (no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/true))
/* DR 757: A type without linkage shall not be used as the type of a
variable or function with linkage, unless
o the variable or function has extern "C" linkage (7.5 [dcl.link]), or
o the variable or function is not used (3.2 [basic.def.odr]) or is
defined in the same translation unit.
Since non-extern "C" decls need to be defined in the same
translation unit, we can make the type internal. */
constrain_visibility (decl, VISIBILITY_ANON, false);
/* If visibility changed and DECL already has DECL_RTL, ensure
symbol flags are updated. */
if ((DECL_VISIBILITY (decl) != orig_visibility
|| DECL_VISIBILITY_SPECIFIED (decl) != orig_visibility_specified)
&& ((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
|| TREE_CODE (decl) == FUNCTION_DECL)
&& DECL_RTL_SET_P (decl))
make_decl_rtl (decl);
} | /* Like c_determine_visibility, but with additional C++-specific
behavior.
Function-scope entities can rely on the function's visibility because
it is set in start_preparsed_function.
Class-scope entities cannot rely on the class's visibility until the end
of the enclosing class definition.
Note that because namespaces have multiple independent definitions,
namespace visibility is handled elsewhere using the #pragma visibility
machinery rather than by decorating the namespace declaration.
The goal is for constraints from the type to give a diagnostic, and
other constraints to be applied silently. */ | Like c_determine_visibility, but with additional C++-specific
behavior.
Function-scope entities can rely on the function's visibility because
it is set in start_preparsed_function.
Class-scope entities cannot rely on the class's visibility until the end
of the enclosing class definition.
Note that because namespaces have multiple independent definitions,
namespace visibility is handled elsewhere using the #pragma visibility
machinery rather than by decorating the namespace declaration.
The goal is for constraints from the type to give a diagnostic, and
other constraints to be applied silently. | [
"Like",
"c_determine_visibility",
"but",
"with",
"additional",
"C",
"++",
"-",
"specific",
"behavior",
".",
"Function",
"-",
"scope",
"entities",
"can",
"rely",
"on",
"the",
"function",
"'",
"s",
"visibility",
"because",
"it",
"is",
"set",
"in",
"start_preparsed_function",
".",
"Class",
"-",
"scope",
"entities",
"cannot",
"rely",
"on",
"the",
"class",
"'",
"s",
"visibility",
"until",
"the",
"end",
"of",
"the",
"enclosing",
"class",
"definition",
".",
"Note",
"that",
"because",
"namespaces",
"have",
"multiple",
"independent",
"definitions",
"namespace",
"visibility",
"is",
"handled",
"elsewhere",
"using",
"the",
"#pragma",
"visibility",
"machinery",
"rather",
"than",
"by",
"decorating",
"the",
"namespace",
"declaration",
".",
"The",
"goal",
"is",
"for",
"constraints",
"from",
"the",
"type",
"to",
"give",
"a",
"diagnostic",
"and",
"other",
"constraints",
"to",
"be",
"applied",
"silently",
"."
] | void
determine_visibility (tree decl)
{
tree class_type = NULL_TREE;
bool use_template;
bool orig_visibility_specified;
enum symbol_visibility orig_visibility;
if (!TREE_PUBLIC (decl))
return;
gcc_assert (!DECL_CLONED_FUNCTION_P (decl));
orig_visibility_specified = DECL_VISIBILITY_SPECIFIED (decl);
orig_visibility = DECL_VISIBILITY (decl);
if (TREE_CODE (decl) == TYPE_DECL)
{
if (CLASS_TYPE_P (TREE_TYPE (decl)))
use_template = CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl));
else if (TYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
use_template = 1;
else
use_template = 0;
}
else if (DECL_LANG_SPECIFIC (decl))
use_template = DECL_USE_TEMPLATE (decl);
else
use_template = 0;
if (DECL_CLASS_SCOPE_P (decl))
class_type = DECL_CONTEXT (decl);
else
{
gcc_assert (TREE_CODE (decl) != VAR_DECL
|| !DECL_VTABLE_OR_VTT_P (decl));
if (DECL_FUNCTION_SCOPE_P (decl) && ! DECL_VISIBILITY_SPECIFIED (decl))
{
tree fn = DECL_CONTEXT (decl);
if (DECL_VISIBILITY_SPECIFIED (fn))
{
DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn);
DECL_VISIBILITY_SPECIFIED (decl) =
DECL_VISIBILITY_SPECIFIED (fn);
}
else
{
if (DECL_CLASS_SCOPE_P (fn))
determine_visibility_from_class (decl, DECL_CONTEXT (fn));
else if (determine_hidden_inline (fn))
{
DECL_VISIBILITY (decl) = default_visibility;
DECL_VISIBILITY_SPECIFIED (decl) =
visibility_options.inpragma;
}
else
{
DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn);
DECL_VISIBILITY_SPECIFIED (decl) =
DECL_VISIBILITY_SPECIFIED (fn);
}
}
use_template = 0;
}
else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl)
&& flag_visibility_ms_compat)
{
tree underlying_type = TREE_TYPE (DECL_NAME (decl));
int underlying_vis = type_visibility (underlying_type);
if (underlying_vis == VISIBILITY_ANON
|| (CLASS_TYPE_P (underlying_type)
&& CLASSTYPE_VISIBILITY_SPECIFIED (underlying_type)))
constrain_visibility (decl, underlying_vis, false);
else
DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
}
else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl))
{
constrain_visibility
(decl, type_visibility (TREE_TYPE (DECL_NAME (decl))), false);
if (TREE_PUBLIC (decl)
&& !DECL_REALLY_EXTERN (decl)
&& CLASS_TYPE_P (TREE_TYPE (DECL_NAME (decl)))
&& !CLASSTYPE_VISIBILITY_SPECIFIED (TREE_TYPE (DECL_NAME (decl))))
targetm.cxx.determine_class_data_visibility (decl);
}
else if (use_template)
;
else if (! DECL_VISIBILITY_SPECIFIED (decl))
{
if (determine_hidden_inline (decl))
DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
else
{
DECL_VISIBILITY (decl) = default_visibility;
DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
}
}
}
if (use_template)
{
tree tinfo = (TREE_CODE (decl) == TYPE_DECL
? TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
: DECL_TEMPLATE_INFO (decl));
tree args = TI_ARGS (tinfo);
tree attribs = (TREE_CODE (decl) == TYPE_DECL
? TYPE_ATTRIBUTES (TREE_TYPE (decl))
: DECL_ATTRIBUTES (decl));
if (args != error_mark_node
&& !lookup_attribute ("visibility", attribs))
{
int depth = TMPL_ARGS_DEPTH (args);
tree pattern = DECL_TEMPLATE_RESULT (TI_TEMPLATE (tinfo));
if (!DECL_VISIBILITY_SPECIFIED (decl))
{
if (!DECL_VISIBILITY_SPECIFIED (pattern)
&& determine_hidden_inline (decl))
DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
else
{
DECL_VISIBILITY (decl) = DECL_VISIBILITY (pattern);
DECL_VISIBILITY_SPECIFIED (decl)
= DECL_VISIBILITY_SPECIFIED (pattern);
}
}
if (args && depth > template_class_depth (class_type))
constrain_visibility_for_template (decl, args);
}
}
if (class_type)
determine_visibility_from_class (decl, class_type);
if (decl_anon_ns_mem_p (decl))
constrain_visibility (decl, VISIBILITY_ANON, false);
else if (TREE_CODE (decl) != TYPE_DECL)
{
int tvis = type_visibility (TREE_TYPE (decl));
if (tvis == VISIBILITY_ANON
|| ! DECL_VISIBILITY_SPECIFIED (decl))
constrain_visibility (decl, tvis, false);
}
else if (no_linkage_check (TREE_TYPE (decl), true))
constrain_visibility (decl, VISIBILITY_ANON, false);
if ((DECL_VISIBILITY (decl) != orig_visibility
|| DECL_VISIBILITY_SPECIFIED (decl) != orig_visibility_specified)
&& ((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
|| TREE_CODE (decl) == FUNCTION_DECL)
&& DECL_RTL_SET_P (decl))
make_decl_rtl (decl);
} | [
"void",
"determine_visibility",
"(",
"tree",
"decl",
")",
"{",
"tree",
"class_type",
"=",
"NULL_TREE",
";",
"bool",
"use_template",
";",
"bool",
"orig_visibility_specified",
";",
"enum",
"symbol_visibility",
"orig_visibility",
";",
"if",
"(",
"!",
"TREE_PUBLIC",
"(",
"decl",
")",
")",
"return",
";",
"gcc_assert",
"(",
"!",
"DECL_CLONED_FUNCTION_P",
"(",
"decl",
")",
")",
";",
"orig_visibility_specified",
"=",
"DECL_VISIBILITY_SPECIFIED",
"(",
"decl",
")",
";",
"orig_visibility",
"=",
"DECL_VISIBILITY",
"(",
"decl",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"TYPE_DECL",
")",
"{",
"if",
"(",
"CLASS_TYPE_P",
"(",
"TREE_TYPE",
"(",
"decl",
")",
")",
")",
"use_template",
"=",
"CLASSTYPE_USE_TEMPLATE",
"(",
"TREE_TYPE",
"(",
"decl",
")",
")",
";",
"else",
"if",
"(",
"TYPE_TEMPLATE_INFO",
"(",
"TREE_TYPE",
"(",
"decl",
")",
")",
")",
"use_template",
"=",
"1",
";",
"else",
"use_template",
"=",
"0",
";",
"}",
"else",
"if",
"(",
"DECL_LANG_SPECIFIC",
"(",
"decl",
")",
")",
"use_template",
"=",
"DECL_USE_TEMPLATE",
"(",
"decl",
")",
";",
"else",
"use_template",
"=",
"0",
";",
"if",
"(",
"DECL_CLASS_SCOPE_P",
"(",
"decl",
")",
")",
"class_type",
"=",
"DECL_CONTEXT",
"(",
"decl",
")",
";",
"else",
"{",
"gcc_assert",
"(",
"TREE_CODE",
"(",
"decl",
")",
"!=",
"VAR_DECL",
"||",
"!",
"DECL_VTABLE_OR_VTT_P",
"(",
"decl",
")",
")",
";",
"if",
"(",
"DECL_FUNCTION_SCOPE_P",
"(",
"decl",
")",
"&&",
"!",
"DECL_VISIBILITY_SPECIFIED",
"(",
"decl",
")",
")",
"{",
"tree",
"fn",
"=",
"DECL_CONTEXT",
"(",
"decl",
")",
";",
"if",
"(",
"DECL_VISIBILITY_SPECIFIED",
"(",
"fn",
")",
")",
"{",
"DECL_VISIBILITY",
"(",
"decl",
")",
"=",
"DECL_VISIBILITY",
"(",
"fn",
")",
";",
"DECL_VISIBILITY_SPECIFIED",
"(",
"decl",
")",
"=",
"DECL_VISIBILITY_SPECIFIED",
"(",
"fn",
")",
";",
"}",
"else",
"{",
"if",
"(",
"DECL_CLASS_SCOPE_P",
"(",
"fn",
")",
")",
"determine_visibility_from_class",
"(",
"decl",
",",
"DECL_CONTEXT",
"(",
"fn",
")",
")",
";",
"else",
"if",
"(",
"determine_hidden_inline",
"(",
"fn",
")",
")",
"{",
"DECL_VISIBILITY",
"(",
"decl",
")",
"=",
"default_visibility",
";",
"DECL_VISIBILITY_SPECIFIED",
"(",
"decl",
")",
"=",
"visibility_options",
".",
"inpragma",
";",
"}",
"else",
"{",
"DECL_VISIBILITY",
"(",
"decl",
")",
"=",
"DECL_VISIBILITY",
"(",
"fn",
")",
";",
"DECL_VISIBILITY_SPECIFIED",
"(",
"decl",
")",
"=",
"DECL_VISIBILITY_SPECIFIED",
"(",
"fn",
")",
";",
"}",
"}",
"use_template",
"=",
"0",
";",
"}",
"else",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"VAR_DECL",
"&&",
"DECL_TINFO_P",
"(",
"decl",
")",
"&&",
"flag_visibility_ms_compat",
")",
"{",
"tree",
"underlying_type",
"=",
"TREE_TYPE",
"(",
"DECL_NAME",
"(",
"decl",
")",
")",
";",
"int",
"underlying_vis",
"=",
"type_visibility",
"(",
"underlying_type",
")",
";",
"if",
"(",
"underlying_vis",
"==",
"VISIBILITY_ANON",
"||",
"(",
"CLASS_TYPE_P",
"(",
"underlying_type",
")",
"&&",
"CLASSTYPE_VISIBILITY_SPECIFIED",
"(",
"underlying_type",
")",
")",
")",
"constrain_visibility",
"(",
"decl",
",",
"underlying_vis",
",",
"false",
")",
";",
"else",
"DECL_VISIBILITY",
"(",
"decl",
")",
"=",
"VISIBILITY_DEFAULT",
";",
"}",
"else",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"VAR_DECL",
"&&",
"DECL_TINFO_P",
"(",
"decl",
")",
")",
"{",
"constrain_visibility",
"(",
"decl",
",",
"type_visibility",
"(",
"TREE_TYPE",
"(",
"DECL_NAME",
"(",
"decl",
")",
")",
")",
",",
"false",
")",
";",
"if",
"(",
"TREE_PUBLIC",
"(",
"decl",
")",
"&&",
"!",
"DECL_REALLY_EXTERN",
"(",
"decl",
")",
"&&",
"CLASS_TYPE_P",
"(",
"TREE_TYPE",
"(",
"DECL_NAME",
"(",
"decl",
")",
")",
")",
"&&",
"!",
"CLASSTYPE_VISIBILITY_SPECIFIED",
"(",
"TREE_TYPE",
"(",
"DECL_NAME",
"(",
"decl",
")",
")",
")",
")",
"targetm",
".",
"cxx",
".",
"determine_class_data_visibility",
"(",
"decl",
")",
";",
"}",
"else",
"if",
"(",
"use_template",
")",
";",
"else",
"if",
"(",
"!",
"DECL_VISIBILITY_SPECIFIED",
"(",
"decl",
")",
")",
"{",
"if",
"(",
"determine_hidden_inline",
"(",
"decl",
")",
")",
"DECL_VISIBILITY",
"(",
"decl",
")",
"=",
"VISIBILITY_HIDDEN",
";",
"else",
"{",
"DECL_VISIBILITY",
"(",
"decl",
")",
"=",
"default_visibility",
";",
"DECL_VISIBILITY_SPECIFIED",
"(",
"decl",
")",
"=",
"visibility_options",
".",
"inpragma",
";",
"}",
"}",
"}",
"if",
"(",
"use_template",
")",
"{",
"tree",
"tinfo",
"=",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"TYPE_DECL",
"?",
"TYPE_TEMPLATE_INFO",
"(",
"TREE_TYPE",
"(",
"decl",
")",
")",
":",
"DECL_TEMPLATE_INFO",
"(",
"decl",
")",
")",
";",
"tree",
"args",
"=",
"TI_ARGS",
"(",
"tinfo",
")",
";",
"tree",
"attribs",
"=",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"TYPE_DECL",
"?",
"TYPE_ATTRIBUTES",
"(",
"TREE_TYPE",
"(",
"decl",
")",
")",
":",
"DECL_ATTRIBUTES",
"(",
"decl",
")",
")",
";",
"if",
"(",
"args",
"!=",
"error_mark_node",
"&&",
"!",
"lookup_attribute",
"(",
"\"",
"\"",
",",
"attribs",
")",
")",
"{",
"int",
"depth",
"=",
"TMPL_ARGS_DEPTH",
"(",
"args",
")",
";",
"tree",
"pattern",
"=",
"DECL_TEMPLATE_RESULT",
"(",
"TI_TEMPLATE",
"(",
"tinfo",
")",
")",
";",
"if",
"(",
"!",
"DECL_VISIBILITY_SPECIFIED",
"(",
"decl",
")",
")",
"{",
"if",
"(",
"!",
"DECL_VISIBILITY_SPECIFIED",
"(",
"pattern",
")",
"&&",
"determine_hidden_inline",
"(",
"decl",
")",
")",
"DECL_VISIBILITY",
"(",
"decl",
")",
"=",
"VISIBILITY_HIDDEN",
";",
"else",
"{",
"DECL_VISIBILITY",
"(",
"decl",
")",
"=",
"DECL_VISIBILITY",
"(",
"pattern",
")",
";",
"DECL_VISIBILITY_SPECIFIED",
"(",
"decl",
")",
"=",
"DECL_VISIBILITY_SPECIFIED",
"(",
"pattern",
")",
";",
"}",
"}",
"if",
"(",
"args",
"&&",
"depth",
">",
"template_class_depth",
"(",
"class_type",
")",
")",
"constrain_visibility_for_template",
"(",
"decl",
",",
"args",
")",
";",
"}",
"}",
"if",
"(",
"class_type",
")",
"determine_visibility_from_class",
"(",
"decl",
",",
"class_type",
")",
";",
"if",
"(",
"decl_anon_ns_mem_p",
"(",
"decl",
")",
")",
"constrain_visibility",
"(",
"decl",
",",
"VISIBILITY_ANON",
",",
"false",
")",
";",
"else",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"!=",
"TYPE_DECL",
")",
"{",
"int",
"tvis",
"=",
"type_visibility",
"(",
"TREE_TYPE",
"(",
"decl",
")",
")",
";",
"if",
"(",
"tvis",
"==",
"VISIBILITY_ANON",
"||",
"!",
"DECL_VISIBILITY_SPECIFIED",
"(",
"decl",
")",
")",
"constrain_visibility",
"(",
"decl",
",",
"tvis",
",",
"false",
")",
";",
"}",
"else",
"if",
"(",
"no_linkage_check",
"(",
"TREE_TYPE",
"(",
"decl",
")",
",",
"true",
")",
")",
"constrain_visibility",
"(",
"decl",
",",
"VISIBILITY_ANON",
",",
"false",
")",
";",
"if",
"(",
"(",
"DECL_VISIBILITY",
"(",
"decl",
")",
"!=",
"orig_visibility",
"||",
"DECL_VISIBILITY_SPECIFIED",
"(",
"decl",
")",
"!=",
"orig_visibility_specified",
")",
"&&",
"(",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"VAR_DECL",
"&&",
"TREE_STATIC",
"(",
"decl",
")",
")",
"||",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
")",
"&&",
"DECL_RTL_SET_P",
"(",
"decl",
")",
")",
"make_decl_rtl",
"(",
"decl",
")",
";",
"}"
] | Like c_determine_visibility, but with additional C++-specific
behavior. | [
"Like",
"c_determine_visibility",
"but",
"with",
"additional",
"C",
"++",
"-",
"specific",
"behavior",
"."
] | [
"/* Remember that all decls get VISIBILITY_DEFAULT when built. */",
"/* Only relevant for names with external linkage. */",
"/* Cloned constructors and destructors get the same visibility as\n the underlying function. That should be set up in\n maybe_clone_body. */",
"/* If DECL is a member of a class, visibility specifiers on the\n class can influence the visibility of the DECL. */",
"/* Not a class member. */",
"/* Virtual tables have DECL_CONTEXT set to their associated class,\n\t so they are automatically handled above. */",
"/* Local statics and classes get the visibility of their\n\t containing function by default, except that\n\t -fvisibility-inlines-hidden doesn't affect them. */",
"/* Local classes in templates have CLASSTYPE_USE_TEMPLATE set,\n\t but have no TEMPLATE_INFO, so don't try to check it. */",
"/* Under -fvisibility-ms-compat, types are visible by default,\n\t even though their contents aren't. */",
"/* tinfo visibility is based on the type it's for. */",
"/* Give the target a chance to override the visibility associated\n\t with DECL. */",
"/* Template instantiations and specializations get visibility based\n\t on their template unless they override it with an attribute. */",
"/* Set default visibility to whatever the user supplied with\n\t #pragma GCC visibility or a namespace visibility attribute. */",
"/* If the specialization doesn't specify visibility, use the\n\t visibility from the template. */",
"/* Template argument visibility outweighs #pragma or namespace\n\t visibility, but not an explicit attribute. */",
"/* FIXME should TMPL_ARGS_DEPTH really return 1 for null input? */",
"/* Limit visibility based on its template arguments. */",
"/* Names in an anonymous namespace get internal linkage.\n This might change once we implement export. */",
"/* Propagate anonymity from type to decl. */",
"/*relaxed_p=*/",
"/* DR 757: A type without linkage shall not be used as the type of a\n variable or function with linkage, unless\n o the variable or function has extern \"C\" linkage (7.5 [dcl.link]), or\n o the variable or function is not used (3.2 [basic.def.odr]) or is\n defined in the same translation unit.\n\n Since non-extern \"C\" decls need to be defined in the same\n translation unit, we can make the type internal. */",
"/* If visibility changed and DECL already has DECL_RTL, ensure\n symbol flags are updated. */"
] | [
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | determine_visibility_from_class | void | static void
determine_visibility_from_class (tree decl, tree class_type)
{
if (DECL_VISIBILITY_SPECIFIED (decl))
return;
if (determine_hidden_inline (decl))
DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
else
{
/* Default to the class visibility. */
DECL_VISIBILITY (decl) = CLASSTYPE_VISIBILITY (class_type);
DECL_VISIBILITY_SPECIFIED (decl)
= CLASSTYPE_VISIBILITY_SPECIFIED (class_type);
}
/* Give the target a chance to override the visibility associated
with DECL. */
if (TREE_CODE (decl) == VAR_DECL
&& (DECL_TINFO_P (decl)
|| (DECL_VTABLE_OR_VTT_P (decl)
/* Construction virtual tables are not exported because
they cannot be referred to from other object files;
their name is not standardized by the ABI. */
&& !DECL_CONSTRUCTION_VTABLE_P (decl)))
&& TREE_PUBLIC (decl)
&& !DECL_REALLY_EXTERN (decl)
&& !CLASSTYPE_VISIBILITY_SPECIFIED (class_type))
targetm.cxx.determine_class_data_visibility (decl);
} | /* By default, static data members and function members receive
the visibility of their containing class. */ | By default, static data members and function members receive
the visibility of their containing class. | [
"By",
"default",
"static",
"data",
"members",
"and",
"function",
"members",
"receive",
"the",
"visibility",
"of",
"their",
"containing",
"class",
"."
] | static void
determine_visibility_from_class (tree decl, tree class_type)
{
if (DECL_VISIBILITY_SPECIFIED (decl))
return;
if (determine_hidden_inline (decl))
DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
else
{
DECL_VISIBILITY (decl) = CLASSTYPE_VISIBILITY (class_type);
DECL_VISIBILITY_SPECIFIED (decl)
= CLASSTYPE_VISIBILITY_SPECIFIED (class_type);
}
if (TREE_CODE (decl) == VAR_DECL
&& (DECL_TINFO_P (decl)
|| (DECL_VTABLE_OR_VTT_P (decl)
&& !DECL_CONSTRUCTION_VTABLE_P (decl)))
&& TREE_PUBLIC (decl)
&& !DECL_REALLY_EXTERN (decl)
&& !CLASSTYPE_VISIBILITY_SPECIFIED (class_type))
targetm.cxx.determine_class_data_visibility (decl);
} | [
"static",
"void",
"determine_visibility_from_class",
"(",
"tree",
"decl",
",",
"tree",
"class_type",
")",
"{",
"if",
"(",
"DECL_VISIBILITY_SPECIFIED",
"(",
"decl",
")",
")",
"return",
";",
"if",
"(",
"determine_hidden_inline",
"(",
"decl",
")",
")",
"DECL_VISIBILITY",
"(",
"decl",
")",
"=",
"VISIBILITY_HIDDEN",
";",
"else",
"{",
"DECL_VISIBILITY",
"(",
"decl",
")",
"=",
"CLASSTYPE_VISIBILITY",
"(",
"class_type",
")",
";",
"DECL_VISIBILITY_SPECIFIED",
"(",
"decl",
")",
"=",
"CLASSTYPE_VISIBILITY_SPECIFIED",
"(",
"class_type",
")",
";",
"}",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"VAR_DECL",
"&&",
"(",
"DECL_TINFO_P",
"(",
"decl",
")",
"||",
"(",
"DECL_VTABLE_OR_VTT_P",
"(",
"decl",
")",
"&&",
"!",
"DECL_CONSTRUCTION_VTABLE_P",
"(",
"decl",
")",
")",
")",
"&&",
"TREE_PUBLIC",
"(",
"decl",
")",
"&&",
"!",
"DECL_REALLY_EXTERN",
"(",
"decl",
")",
"&&",
"!",
"CLASSTYPE_VISIBILITY_SPECIFIED",
"(",
"class_type",
")",
")",
"targetm",
".",
"cxx",
".",
"determine_class_data_visibility",
"(",
"decl",
")",
";",
"}"
] | By default, static data members and function members receive
the visibility of their containing class. | [
"By",
"default",
"static",
"data",
"members",
"and",
"function",
"members",
"receive",
"the",
"visibility",
"of",
"their",
"containing",
"class",
"."
] | [
"/* Default to the class visibility. */",
"/* Give the target a chance to override the visibility associated\n with DECL. */",
"/* Construction virtual tables are not exported because\n\t\t they cannot be referred to from other object files;\n\t\t their name is not standardized by the ABI. */"
] | [
{
"param": "decl",
"type": "tree"
},
{
"param": "class_type",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "class_type",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | determine_hidden_inline | bool | static bool
determine_hidden_inline (tree decl)
{
return (visibility_options.inlines_hidden
/* Don't do this for inline templates; specializations might not be
inline, and we don't want them to inherit the hidden
visibility. We'll set it here for all inline instantiations. */
&& !processing_template_decl
&& TREE_CODE (decl) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (decl)
&& (! DECL_LANG_SPECIFIC (decl)
|| ! DECL_EXPLICIT_INSTANTIATION (decl)));
} | /* Returns true iff DECL is an inline that should get hidden visibility
because of -fvisibility-inlines-hidden. */ | Returns true iff DECL is an inline that should get hidden visibility
because of -fvisibility-inlines-hidden. | [
"Returns",
"true",
"iff",
"DECL",
"is",
"an",
"inline",
"that",
"should",
"get",
"hidden",
"visibility",
"because",
"of",
"-",
"fvisibility",
"-",
"inlines",
"-",
"hidden",
"."
] | static bool
determine_hidden_inline (tree decl)
{
return (visibility_options.inlines_hidden
&& !processing_template_decl
&& TREE_CODE (decl) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (decl)
&& (! DECL_LANG_SPECIFIC (decl)
|| ! DECL_EXPLICIT_INSTANTIATION (decl)));
} | [
"static",
"bool",
"determine_hidden_inline",
"(",
"tree",
"decl",
")",
"{",
"return",
"(",
"visibility_options",
".",
"inlines_hidden",
"&&",
"!",
"processing_template_decl",
"&&",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
"&&",
"DECL_DECLARED_INLINE_P",
"(",
"decl",
")",
"&&",
"(",
"!",
"DECL_LANG_SPECIFIC",
"(",
"decl",
")",
"||",
"!",
"DECL_EXPLICIT_INSTANTIATION",
"(",
"decl",
")",
")",
")",
";",
"}"
] | Returns true iff DECL is an inline that should get hidden visibility
because of -fvisibility-inlines-hidden. | [
"Returns",
"true",
"iff",
"DECL",
"is",
"an",
"inline",
"that",
"should",
"get",
"hidden",
"visibility",
"because",
"of",
"-",
"fvisibility",
"-",
"inlines",
"-",
"hidden",
"."
] | [
"/* Don't do this for inline templates; specializations might not be\n\t inline, and we don't want them to inherit the hidden\n\t visibility. We'll set it here for all inline instantiations. */"
] | [
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | constrain_class_visibility | void | void
constrain_class_visibility (tree type)
{
tree binfo;
tree t;
int i;
int vis = type_visibility (type);
if (vis == VISIBILITY_ANON
|| DECL_IN_SYSTEM_HEADER (TYPE_MAIN_DECL (type)))
return;
/* Don't warn about visibility if the class has explicit visibility. */
if (CLASSTYPE_VISIBILITY_SPECIFIED (type))
vis = VISIBILITY_INTERNAL;
for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t))
if (TREE_CODE (t) == FIELD_DECL && TREE_TYPE (t) != error_mark_node)
{
tree ftype = strip_pointer_or_array_types (TREE_TYPE (t));
int subvis = type_visibility (ftype);
if (subvis == VISIBILITY_ANON)
{
if (!in_main_input_context ())
warning (0, "\
%qT has a field %qD whose type uses the anonymous namespace",
type, t);
}
else if (MAYBE_CLASS_TYPE_P (ftype)
&& vis < VISIBILITY_HIDDEN
&& subvis >= VISIBILITY_HIDDEN)
warning (OPT_Wattributes, "\
%qT declared with greater visibility than the type of its field %qD",
type, t);
}
binfo = TYPE_BINFO (type);
for (i = 0; BINFO_BASE_ITERATE (binfo, i, t); ++i)
{
int subvis = type_visibility (TREE_TYPE (t));
if (subvis == VISIBILITY_ANON)
{
if (!in_main_input_context())
warning (0, "\
%qT has a base %qT whose type uses the anonymous namespace",
type, TREE_TYPE (t));
}
else if (vis < VISIBILITY_HIDDEN
&& subvis >= VISIBILITY_HIDDEN)
warning (OPT_Wattributes, "\
%qT declared with greater visibility than its base %qT",
type, TREE_TYPE (t));
}
} | /* Constrain the visibility of a class TYPE based on the visibility of its
field types. Warn if any fields require lesser visibility. */ | Constrain the visibility of a class TYPE based on the visibility of its
field types. Warn if any fields require lesser visibility. | [
"Constrain",
"the",
"visibility",
"of",
"a",
"class",
"TYPE",
"based",
"on",
"the",
"visibility",
"of",
"its",
"field",
"types",
".",
"Warn",
"if",
"any",
"fields",
"require",
"lesser",
"visibility",
"."
] | void
constrain_class_visibility (tree type)
{
tree binfo;
tree t;
int i;
int vis = type_visibility (type);
if (vis == VISIBILITY_ANON
|| DECL_IN_SYSTEM_HEADER (TYPE_MAIN_DECL (type)))
return;
if (CLASSTYPE_VISIBILITY_SPECIFIED (type))
vis = VISIBILITY_INTERNAL;
for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t))
if (TREE_CODE (t) == FIELD_DECL && TREE_TYPE (t) != error_mark_node)
{
tree ftype = strip_pointer_or_array_types (TREE_TYPE (t));
int subvis = type_visibility (ftype);
if (subvis == VISIBILITY_ANON)
{
if (!in_main_input_context ())
warning (0, "\
%qT has a field %qD whose type uses the anonymous namespace",
type, t);
}
else if (MAYBE_CLASS_TYPE_P (ftype)
&& vis < VISIBILITY_HIDDEN
&& subvis >= VISIBILITY_HIDDEN)
warning (OPT_Wattributes, "\
%qT declared with greater visibility than the type of its field %qD",
type, t);
}
binfo = TYPE_BINFO (type);
for (i = 0; BINFO_BASE_ITERATE (binfo, i, t); ++i)
{
int subvis = type_visibility (TREE_TYPE (t));
if (subvis == VISIBILITY_ANON)
{
if (!in_main_input_context())
warning (0, "\
%qT has a base %qT whose type uses the anonymous namespace",
type, TREE_TYPE (t));
}
else if (vis < VISIBILITY_HIDDEN
&& subvis >= VISIBILITY_HIDDEN)
warning (OPT_Wattributes, "\
%qT declared with greater visibility than its base %qT",
type, TREE_TYPE (t));
}
} | [
"void",
"constrain_class_visibility",
"(",
"tree",
"type",
")",
"{",
"tree",
"binfo",
";",
"tree",
"t",
";",
"int",
"i",
";",
"int",
"vis",
"=",
"type_visibility",
"(",
"type",
")",
";",
"if",
"(",
"vis",
"==",
"VISIBILITY_ANON",
"||",
"DECL_IN_SYSTEM_HEADER",
"(",
"TYPE_MAIN_DECL",
"(",
"type",
")",
")",
")",
"return",
";",
"if",
"(",
"CLASSTYPE_VISIBILITY_SPECIFIED",
"(",
"type",
")",
")",
"vis",
"=",
"VISIBILITY_INTERNAL",
";",
"for",
"(",
"t",
"=",
"TYPE_FIELDS",
"(",
"type",
")",
";",
"t",
";",
"t",
"=",
"DECL_CHAIN",
"(",
"t",
")",
")",
"if",
"(",
"TREE_CODE",
"(",
"t",
")",
"==",
"FIELD_DECL",
"&&",
"TREE_TYPE",
"(",
"t",
")",
"!=",
"error_mark_node",
")",
"{",
"tree",
"ftype",
"=",
"strip_pointer_or_array_types",
"(",
"TREE_TYPE",
"(",
"t",
")",
")",
";",
"int",
"subvis",
"=",
"type_visibility",
"(",
"ftype",
")",
";",
"if",
"(",
"subvis",
"==",
"VISIBILITY_ANON",
")",
"{",
"if",
"(",
"!",
"in_main_input_context",
"(",
")",
")",
"warning",
"(",
"0",
",",
"\"",
"\\\n",
"\"",
",",
"type",
",",
"t",
")",
";",
"}",
"else",
"if",
"(",
"MAYBE_CLASS_TYPE_P",
"(",
"ftype",
")",
"&&",
"vis",
"<",
"VISIBILITY_HIDDEN",
"&&",
"subvis",
">=",
"VISIBILITY_HIDDEN",
")",
"warning",
"(",
"OPT_Wattributes",
",",
"\"",
"\\\n",
"\"",
",",
"type",
",",
"t",
")",
";",
"}",
"binfo",
"=",
"TYPE_BINFO",
"(",
"type",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"BINFO_BASE_ITERATE",
"(",
"binfo",
",",
"i",
",",
"t",
")",
";",
"++",
"i",
")",
"{",
"int",
"subvis",
"=",
"type_visibility",
"(",
"TREE_TYPE",
"(",
"t",
")",
")",
";",
"if",
"(",
"subvis",
"==",
"VISIBILITY_ANON",
")",
"{",
"if",
"(",
"!",
"in_main_input_context",
"(",
")",
")",
"warning",
"(",
"0",
",",
"\"",
"\\\n",
"\"",
",",
"type",
",",
"TREE_TYPE",
"(",
"t",
")",
")",
";",
"}",
"else",
"if",
"(",
"vis",
"<",
"VISIBILITY_HIDDEN",
"&&",
"subvis",
">=",
"VISIBILITY_HIDDEN",
")",
"warning",
"(",
"OPT_Wattributes",
",",
"\"",
"\\\n",
"\"",
",",
"type",
",",
"TREE_TYPE",
"(",
"t",
")",
")",
";",
"}",
"}"
] | Constrain the visibility of a class TYPE based on the visibility of its
field types. | [
"Constrain",
"the",
"visibility",
"of",
"a",
"class",
"TYPE",
"based",
"on",
"the",
"visibility",
"of",
"its",
"field",
"types",
"."
] | [
"/* Don't warn about visibility if the class has explicit visibility. */"
] | [
{
"param": "type",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "type",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | import_export_decl | void | void
import_export_decl (tree decl)
{
int emit_p;
bool comdat_p;
bool import_p;
tree class_type = NULL_TREE;
if (DECL_INTERFACE_KNOWN (decl))
return;
/* We cannot determine what linkage to give to an entity with vague
linkage until the end of the file. For example, a virtual table
for a class will be defined if and only if the key method is
defined in this translation unit. As a further example, consider
that when compiling a translation unit that uses PCH file with
"-frepo" it would be incorrect to make decisions about what
entities to emit when building the PCH; those decisions must be
delayed until the repository information has been processed. */
gcc_assert (at_eof);
/* Object file linkage for explicit instantiations is handled in
mark_decl_instantiated. For static variables in functions with
vague linkage, maybe_commonize_var is used.
Therefore, the only declarations that should be provided to this
function are those with external linkage that are:
* implicit instantiations of function templates
* inline function
* implicit instantiations of static data members of class
templates
* virtual tables
* typeinfo objects
Furthermore, all entities that reach this point must have a
definition available in this translation unit.
The following assertions check these conditions. */
gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
|| TREE_CODE (decl) == VAR_DECL);
/* Any code that creates entities with TREE_PUBLIC cleared should
also set DECL_INTERFACE_KNOWN. */
gcc_assert (TREE_PUBLIC (decl));
if (TREE_CODE (decl) == FUNCTION_DECL)
gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl)
|| DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl)
|| DECL_DECLARED_INLINE_P (decl));
else
gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl)
|| DECL_VTABLE_OR_VTT_P (decl)
|| DECL_TINFO_P (decl));
/* Check that a definition of DECL is available in this translation
unit. */
gcc_assert (!DECL_REALLY_EXTERN (decl));
/* Assume that DECL will not have COMDAT linkage. */
comdat_p = false;
/* Assume that DECL will not be imported into this translation
unit. */
import_p = false;
/* See if the repository tells us whether or not to emit DECL in
this translation unit. */
emit_p = repo_emit_p (decl);
if (emit_p == 0)
import_p = true;
else if (emit_p == 1)
{
/* The repository indicates that this entity should be defined
here. Make sure the back end honors that request. */
if (TREE_CODE (decl) == VAR_DECL)
mark_needed (decl);
else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
|| DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
{
tree clone;
FOR_EACH_CLONE (clone, decl)
mark_needed (clone);
}
else
mark_needed (decl);
/* Output the definition as an ordinary strong definition. */
DECL_EXTERNAL (decl) = 0;
DECL_INTERFACE_KNOWN (decl) = 1;
return;
}
if (import_p)
/* We have already decided what to do with this DECL; there is no
need to check anything further. */
;
else if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
{
class_type = DECL_CONTEXT (decl);
import_export_class (class_type);
if (TYPE_FOR_JAVA (class_type))
import_p = true;
else if (CLASSTYPE_INTERFACE_KNOWN (class_type)
&& CLASSTYPE_INTERFACE_ONLY (class_type))
import_p = true;
else if ((!flag_weak || TARGET_WEAK_NOT_IN_ARCHIVE_TOC)
&& !CLASSTYPE_USE_TEMPLATE (class_type)
&& CLASSTYPE_KEY_METHOD (class_type)
&& !DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type)))
/* The ABI requires that all virtual tables be emitted with
COMDAT linkage. However, on systems where COMDAT symbols
don't show up in the table of contents for a static
archive, or on systems without weak symbols (where we
approximate COMDAT linkage by using internal linkage), the
linker will report errors about undefined symbols because
it will not see the virtual table definition. Therefore,
in the case that we know that the virtual table will be
emitted in only one translation unit, we make the virtual
table an ordinary definition with external linkage. */
DECL_EXTERNAL (decl) = 0;
else if (CLASSTYPE_INTERFACE_KNOWN (class_type))
{
/* CLASS_TYPE is being exported from this translation unit,
so DECL should be defined here. */
if (!flag_weak && CLASSTYPE_EXPLICIT_INSTANTIATION (class_type))
/* If a class is declared in a header with the "extern
template" extension, then it will not be instantiated,
even in translation units that would normally require
it. Often such classes are explicitly instantiated in
one translation unit. Therefore, the explicit
instantiation must be made visible to other translation
units. */
DECL_EXTERNAL (decl) = 0;
else
{
/* The generic C++ ABI says that class data is always
COMDAT, even if there is a key function. Some
variants (e.g., the ARM EABI) says that class data
only has COMDAT linkage if the class data might be
emitted in more than one translation unit. When the
key method can be inline and is inline, we still have
to arrange for comdat even though
class_data_always_comdat is false. */
if (!CLASSTYPE_KEY_METHOD (class_type)
|| DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type))
|| targetm.cxx.class_data_always_comdat ())
{
/* The ABI requires COMDAT linkage. Normally, we
only emit COMDAT things when they are needed;
make sure that we realize that this entity is
indeed needed. */
comdat_p = true;
mark_needed (decl);
}
}
}
else if (!flag_implicit_templates
&& CLASSTYPE_IMPLICIT_INSTANTIATION (class_type))
import_p = true;
else
comdat_p = true;
}
else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl))
{
tree type = TREE_TYPE (DECL_NAME (decl));
if (CLASS_TYPE_P (type))
{
class_type = type;
import_export_class (type);
if (CLASSTYPE_INTERFACE_KNOWN (type)
&& TYPE_POLYMORPHIC_P (type)
&& CLASSTYPE_INTERFACE_ONLY (type)
/* If -fno-rtti was specified, then we cannot be sure
that RTTI information will be emitted with the
virtual table of the class, so we must emit it
wherever it is used. */
&& flag_rtti)
import_p = true;
else
{
if (CLASSTYPE_INTERFACE_KNOWN (type)
&& !CLASSTYPE_INTERFACE_ONLY (type))
{
comdat_p = (targetm.cxx.class_data_always_comdat ()
|| (CLASSTYPE_KEY_METHOD (type)
&& DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (type))));
mark_needed (decl);
if (!flag_weak)
{
comdat_p = false;
DECL_EXTERNAL (decl) = 0;
}
}
else
comdat_p = true;
}
}
else
comdat_p = true;
}
else if (DECL_TEMPLATE_INSTANTIATION (decl)
|| DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
{
/* DECL is an implicit instantiation of a function or static
data member. */
if ((flag_implicit_templates
&& !flag_use_repository)
|| (flag_implicit_inline_templates
&& TREE_CODE (decl) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (decl)))
comdat_p = true;
else
/* If we are not implicitly generating templates, then mark
this entity as undefined in this translation unit. */
import_p = true;
}
else if (DECL_FUNCTION_MEMBER_P (decl))
{
if (!DECL_DECLARED_INLINE_P (decl))
{
tree ctype = DECL_CONTEXT (decl);
import_export_class (ctype);
if (CLASSTYPE_INTERFACE_KNOWN (ctype))
{
DECL_NOT_REALLY_EXTERN (decl)
= ! (CLASSTYPE_INTERFACE_ONLY (ctype)
|| (DECL_DECLARED_INLINE_P (decl)
&& ! flag_implement_inlines
&& !DECL_VINDEX (decl)));
if (!DECL_NOT_REALLY_EXTERN (decl))
DECL_EXTERNAL (decl) = 1;
/* Always make artificials weak. */
if (DECL_ARTIFICIAL (decl) && flag_weak)
comdat_p = true;
else
maybe_make_one_only (decl);
}
}
else
comdat_p = true;
}
else
comdat_p = true;
if (import_p)
{
/* If we are importing DECL into this translation unit, mark is
an undefined here. */
DECL_EXTERNAL (decl) = 1;
DECL_NOT_REALLY_EXTERN (decl) = 0;
}
else if (comdat_p)
{
/* If we decided to put DECL in COMDAT, mark it accordingly at
this point. */
comdat_linkage (decl);
}
DECL_INTERFACE_KNOWN (decl) = 1;
} | /* DECL is a FUNCTION_DECL or VAR_DECL. If the object file linkage
for DECL has not already been determined, do so now by setting
DECL_EXTERNAL, DECL_COMDAT and other related flags. Until this
function is called entities with vague linkage whose definitions
are available must have TREE_PUBLIC set.
If this function decides to place DECL in COMDAT, it will set
appropriate flags -- but will not clear DECL_EXTERNAL. It is up to
the caller to decide whether or not to clear DECL_EXTERNAL. Some
callers defer that decision until it is clear that DECL is actually
required. */ |
If this function decides to place DECL in COMDAT, it will set
appropriate flags -- but will not clear DECL_EXTERNAL. It is up to
the caller to decide whether or not to clear DECL_EXTERNAL. Some
callers defer that decision until it is clear that DECL is actually
required. | [
"If",
"this",
"function",
"decides",
"to",
"place",
"DECL",
"in",
"COMDAT",
"it",
"will",
"set",
"appropriate",
"flags",
"--",
"but",
"will",
"not",
"clear",
"DECL_EXTERNAL",
".",
"It",
"is",
"up",
"to",
"the",
"caller",
"to",
"decide",
"whether",
"or",
"not",
"to",
"clear",
"DECL_EXTERNAL",
".",
"Some",
"callers",
"defer",
"that",
"decision",
"until",
"it",
"is",
"clear",
"that",
"DECL",
"is",
"actually",
"required",
"."
] | void
import_export_decl (tree decl)
{
int emit_p;
bool comdat_p;
bool import_p;
tree class_type = NULL_TREE;
if (DECL_INTERFACE_KNOWN (decl))
return;
gcc_assert (at_eof);
gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
|| TREE_CODE (decl) == VAR_DECL);
gcc_assert (TREE_PUBLIC (decl));
if (TREE_CODE (decl) == FUNCTION_DECL)
gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl)
|| DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl)
|| DECL_DECLARED_INLINE_P (decl));
else
gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl)
|| DECL_VTABLE_OR_VTT_P (decl)
|| DECL_TINFO_P (decl));
gcc_assert (!DECL_REALLY_EXTERN (decl));
comdat_p = false;
import_p = false;
emit_p = repo_emit_p (decl);
if (emit_p == 0)
import_p = true;
else if (emit_p == 1)
{
if (TREE_CODE (decl) == VAR_DECL)
mark_needed (decl);
else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
|| DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
{
tree clone;
FOR_EACH_CLONE (clone, decl)
mark_needed (clone);
}
else
mark_needed (decl);
DECL_EXTERNAL (decl) = 0;
DECL_INTERFACE_KNOWN (decl) = 1;
return;
}
if (import_p)
;
else if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
{
class_type = DECL_CONTEXT (decl);
import_export_class (class_type);
if (TYPE_FOR_JAVA (class_type))
import_p = true;
else if (CLASSTYPE_INTERFACE_KNOWN (class_type)
&& CLASSTYPE_INTERFACE_ONLY (class_type))
import_p = true;
else if ((!flag_weak || TARGET_WEAK_NOT_IN_ARCHIVE_TOC)
&& !CLASSTYPE_USE_TEMPLATE (class_type)
&& CLASSTYPE_KEY_METHOD (class_type)
&& !DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type)))
DECL_EXTERNAL (decl) = 0;
else if (CLASSTYPE_INTERFACE_KNOWN (class_type))
{
if (!flag_weak && CLASSTYPE_EXPLICIT_INSTANTIATION (class_type))
DECL_EXTERNAL (decl) = 0;
else
{
if (!CLASSTYPE_KEY_METHOD (class_type)
|| DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type))
|| targetm.cxx.class_data_always_comdat ())
{
comdat_p = true;
mark_needed (decl);
}
}
}
else if (!flag_implicit_templates
&& CLASSTYPE_IMPLICIT_INSTANTIATION (class_type))
import_p = true;
else
comdat_p = true;
}
else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl))
{
tree type = TREE_TYPE (DECL_NAME (decl));
if (CLASS_TYPE_P (type))
{
class_type = type;
import_export_class (type);
if (CLASSTYPE_INTERFACE_KNOWN (type)
&& TYPE_POLYMORPHIC_P (type)
&& CLASSTYPE_INTERFACE_ONLY (type)
&& flag_rtti)
import_p = true;
else
{
if (CLASSTYPE_INTERFACE_KNOWN (type)
&& !CLASSTYPE_INTERFACE_ONLY (type))
{
comdat_p = (targetm.cxx.class_data_always_comdat ()
|| (CLASSTYPE_KEY_METHOD (type)
&& DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (type))));
mark_needed (decl);
if (!flag_weak)
{
comdat_p = false;
DECL_EXTERNAL (decl) = 0;
}
}
else
comdat_p = true;
}
}
else
comdat_p = true;
}
else if (DECL_TEMPLATE_INSTANTIATION (decl)
|| DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
{
if ((flag_implicit_templates
&& !flag_use_repository)
|| (flag_implicit_inline_templates
&& TREE_CODE (decl) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (decl)))
comdat_p = true;
else
import_p = true;
}
else if (DECL_FUNCTION_MEMBER_P (decl))
{
if (!DECL_DECLARED_INLINE_P (decl))
{
tree ctype = DECL_CONTEXT (decl);
import_export_class (ctype);
if (CLASSTYPE_INTERFACE_KNOWN (ctype))
{
DECL_NOT_REALLY_EXTERN (decl)
= ! (CLASSTYPE_INTERFACE_ONLY (ctype)
|| (DECL_DECLARED_INLINE_P (decl)
&& ! flag_implement_inlines
&& !DECL_VINDEX (decl)));
if (!DECL_NOT_REALLY_EXTERN (decl))
DECL_EXTERNAL (decl) = 1;
if (DECL_ARTIFICIAL (decl) && flag_weak)
comdat_p = true;
else
maybe_make_one_only (decl);
}
}
else
comdat_p = true;
}
else
comdat_p = true;
if (import_p)
{
DECL_EXTERNAL (decl) = 1;
DECL_NOT_REALLY_EXTERN (decl) = 0;
}
else if (comdat_p)
{
comdat_linkage (decl);
}
DECL_INTERFACE_KNOWN (decl) = 1;
} | [
"void",
"import_export_decl",
"(",
"tree",
"decl",
")",
"{",
"int",
"emit_p",
";",
"bool",
"comdat_p",
";",
"bool",
"import_p",
";",
"tree",
"class_type",
"=",
"NULL_TREE",
";",
"if",
"(",
"DECL_INTERFACE_KNOWN",
"(",
"decl",
")",
")",
"return",
";",
"gcc_assert",
"(",
"at_eof",
")",
";",
"gcc_assert",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
"||",
"TREE_CODE",
"(",
"decl",
")",
"==",
"VAR_DECL",
")",
";",
"gcc_assert",
"(",
"TREE_PUBLIC",
"(",
"decl",
")",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
")",
"gcc_assert",
"(",
"DECL_IMPLICIT_INSTANTIATION",
"(",
"decl",
")",
"||",
"DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION",
"(",
"decl",
")",
"||",
"DECL_DECLARED_INLINE_P",
"(",
"decl",
")",
")",
";",
"else",
"gcc_assert",
"(",
"DECL_IMPLICIT_INSTANTIATION",
"(",
"decl",
")",
"||",
"DECL_VTABLE_OR_VTT_P",
"(",
"decl",
")",
"||",
"DECL_TINFO_P",
"(",
"decl",
")",
")",
";",
"gcc_assert",
"(",
"!",
"DECL_REALLY_EXTERN",
"(",
"decl",
")",
")",
";",
"comdat_p",
"=",
"false",
";",
"import_p",
"=",
"false",
";",
"emit_p",
"=",
"repo_emit_p",
"(",
"decl",
")",
";",
"if",
"(",
"emit_p",
"==",
"0",
")",
"import_p",
"=",
"true",
";",
"else",
"if",
"(",
"emit_p",
"==",
"1",
")",
"{",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"VAR_DECL",
")",
"mark_needed",
"(",
"decl",
")",
";",
"else",
"if",
"(",
"DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P",
"(",
"decl",
")",
"||",
"DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P",
"(",
"decl",
")",
")",
"{",
"tree",
"clone",
";",
"FOR_EACH_CLONE",
"(",
"clone",
",",
"decl",
")",
"",
"mark_needed",
"(",
"clone",
")",
";",
"}",
"else",
"mark_needed",
"(",
"decl",
")",
";",
"DECL_EXTERNAL",
"(",
"decl",
")",
"=",
"0",
";",
"DECL_INTERFACE_KNOWN",
"(",
"decl",
")",
"=",
"1",
";",
"return",
";",
"}",
"if",
"(",
"import_p",
")",
";",
"else",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"VAR_DECL",
"&&",
"DECL_VTABLE_OR_VTT_P",
"(",
"decl",
")",
")",
"{",
"class_type",
"=",
"DECL_CONTEXT",
"(",
"decl",
")",
";",
"import_export_class",
"(",
"class_type",
")",
";",
"if",
"(",
"TYPE_FOR_JAVA",
"(",
"class_type",
")",
")",
"import_p",
"=",
"true",
";",
"else",
"if",
"(",
"CLASSTYPE_INTERFACE_KNOWN",
"(",
"class_type",
")",
"&&",
"CLASSTYPE_INTERFACE_ONLY",
"(",
"class_type",
")",
")",
"import_p",
"=",
"true",
";",
"else",
"if",
"(",
"(",
"!",
"flag_weak",
"||",
"TARGET_WEAK_NOT_IN_ARCHIVE_TOC",
")",
"&&",
"!",
"CLASSTYPE_USE_TEMPLATE",
"(",
"class_type",
")",
"&&",
"CLASSTYPE_KEY_METHOD",
"(",
"class_type",
")",
"&&",
"!",
"DECL_DECLARED_INLINE_P",
"(",
"CLASSTYPE_KEY_METHOD",
"(",
"class_type",
")",
")",
")",
"DECL_EXTERNAL",
"(",
"decl",
")",
"=",
"0",
";",
"else",
"if",
"(",
"CLASSTYPE_INTERFACE_KNOWN",
"(",
"class_type",
")",
")",
"{",
"if",
"(",
"!",
"flag_weak",
"&&",
"CLASSTYPE_EXPLICIT_INSTANTIATION",
"(",
"class_type",
")",
")",
"DECL_EXTERNAL",
"(",
"decl",
")",
"=",
"0",
";",
"else",
"{",
"if",
"(",
"!",
"CLASSTYPE_KEY_METHOD",
"(",
"class_type",
")",
"||",
"DECL_DECLARED_INLINE_P",
"(",
"CLASSTYPE_KEY_METHOD",
"(",
"class_type",
")",
")",
"||",
"targetm",
".",
"cxx",
".",
"class_data_always_comdat",
"(",
")",
")",
"{",
"comdat_p",
"=",
"true",
";",
"mark_needed",
"(",
"decl",
")",
";",
"}",
"}",
"}",
"else",
"if",
"(",
"!",
"flag_implicit_templates",
"&&",
"CLASSTYPE_IMPLICIT_INSTANTIATION",
"(",
"class_type",
")",
")",
"import_p",
"=",
"true",
";",
"else",
"comdat_p",
"=",
"true",
";",
"}",
"else",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"VAR_DECL",
"&&",
"DECL_TINFO_P",
"(",
"decl",
")",
")",
"{",
"tree",
"type",
"=",
"TREE_TYPE",
"(",
"DECL_NAME",
"(",
"decl",
")",
")",
";",
"if",
"(",
"CLASS_TYPE_P",
"(",
"type",
")",
")",
"{",
"class_type",
"=",
"type",
";",
"import_export_class",
"(",
"type",
")",
";",
"if",
"(",
"CLASSTYPE_INTERFACE_KNOWN",
"(",
"type",
")",
"&&",
"TYPE_POLYMORPHIC_P",
"(",
"type",
")",
"&&",
"CLASSTYPE_INTERFACE_ONLY",
"(",
"type",
")",
"&&",
"flag_rtti",
")",
"import_p",
"=",
"true",
";",
"else",
"{",
"if",
"(",
"CLASSTYPE_INTERFACE_KNOWN",
"(",
"type",
")",
"&&",
"!",
"CLASSTYPE_INTERFACE_ONLY",
"(",
"type",
")",
")",
"{",
"comdat_p",
"=",
"(",
"targetm",
".",
"cxx",
".",
"class_data_always_comdat",
"(",
")",
"||",
"(",
"CLASSTYPE_KEY_METHOD",
"(",
"type",
")",
"&&",
"DECL_DECLARED_INLINE_P",
"(",
"CLASSTYPE_KEY_METHOD",
"(",
"type",
")",
")",
")",
")",
";",
"mark_needed",
"(",
"decl",
")",
";",
"if",
"(",
"!",
"flag_weak",
")",
"{",
"comdat_p",
"=",
"false",
";",
"DECL_EXTERNAL",
"(",
"decl",
")",
"=",
"0",
";",
"}",
"}",
"else",
"comdat_p",
"=",
"true",
";",
"}",
"}",
"else",
"comdat_p",
"=",
"true",
";",
"}",
"else",
"if",
"(",
"DECL_TEMPLATE_INSTANTIATION",
"(",
"decl",
")",
"||",
"DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION",
"(",
"decl",
")",
")",
"{",
"if",
"(",
"(",
"flag_implicit_templates",
"&&",
"!",
"flag_use_repository",
")",
"||",
"(",
"flag_implicit_inline_templates",
"&&",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
"&&",
"DECL_DECLARED_INLINE_P",
"(",
"decl",
")",
")",
")",
"comdat_p",
"=",
"true",
";",
"else",
"import_p",
"=",
"true",
";",
"}",
"else",
"if",
"(",
"DECL_FUNCTION_MEMBER_P",
"(",
"decl",
")",
")",
"{",
"if",
"(",
"!",
"DECL_DECLARED_INLINE_P",
"(",
"decl",
")",
")",
"{",
"tree",
"ctype",
"=",
"DECL_CONTEXT",
"(",
"decl",
")",
";",
"import_export_class",
"(",
"ctype",
")",
";",
"if",
"(",
"CLASSTYPE_INTERFACE_KNOWN",
"(",
"ctype",
")",
")",
"{",
"DECL_NOT_REALLY_EXTERN",
"(",
"decl",
")",
"=",
"!",
"(",
"CLASSTYPE_INTERFACE_ONLY",
"(",
"ctype",
")",
"||",
"(",
"DECL_DECLARED_INLINE_P",
"(",
"decl",
")",
"&&",
"!",
"flag_implement_inlines",
"&&",
"!",
"DECL_VINDEX",
"(",
"decl",
")",
")",
")",
";",
"if",
"(",
"!",
"DECL_NOT_REALLY_EXTERN",
"(",
"decl",
")",
")",
"DECL_EXTERNAL",
"(",
"decl",
")",
"=",
"1",
";",
"if",
"(",
"DECL_ARTIFICIAL",
"(",
"decl",
")",
"&&",
"flag_weak",
")",
"comdat_p",
"=",
"true",
";",
"else",
"maybe_make_one_only",
"(",
"decl",
")",
";",
"}",
"}",
"else",
"comdat_p",
"=",
"true",
";",
"}",
"else",
"comdat_p",
"=",
"true",
";",
"if",
"(",
"import_p",
")",
"{",
"DECL_EXTERNAL",
"(",
"decl",
")",
"=",
"1",
";",
"DECL_NOT_REALLY_EXTERN",
"(",
"decl",
")",
"=",
"0",
";",
"}",
"else",
"if",
"(",
"comdat_p",
")",
"{",
"comdat_linkage",
"(",
"decl",
")",
";",
"}",
"DECL_INTERFACE_KNOWN",
"(",
"decl",
")",
"=",
"1",
";",
"}"
] | DECL is a FUNCTION_DECL or VAR_DECL. | [
"DECL",
"is",
"a",
"FUNCTION_DECL",
"or",
"VAR_DECL",
"."
] | [
"/* We cannot determine what linkage to give to an entity with vague\n linkage until the end of the file. For example, a virtual table\n for a class will be defined if and only if the key method is\n defined in this translation unit. As a further example, consider\n that when compiling a translation unit that uses PCH file with\n \"-frepo\" it would be incorrect to make decisions about what\n entities to emit when building the PCH; those decisions must be\n delayed until the repository information has been processed. */",
"/* Object file linkage for explicit instantiations is handled in\n mark_decl_instantiated. For static variables in functions with\n vague linkage, maybe_commonize_var is used.\n\n Therefore, the only declarations that should be provided to this\n function are those with external linkage that are:\n\n * implicit instantiations of function templates\n\n * inline function\n\n * implicit instantiations of static data members of class\n templates\n\n * virtual tables\n\n * typeinfo objects\n\n Furthermore, all entities that reach this point must have a\n definition available in this translation unit.\n\n The following assertions check these conditions. */",
"/* Any code that creates entities with TREE_PUBLIC cleared should\n also set DECL_INTERFACE_KNOWN. */",
"/* Check that a definition of DECL is available in this translation\n unit. */",
"/* Assume that DECL will not have COMDAT linkage. */",
"/* Assume that DECL will not be imported into this translation\n unit. */",
"/* See if the repository tells us whether or not to emit DECL in\n this translation unit. */",
"/* The repository indicates that this entity should be defined\n\t here. Make sure the back end honors that request. */",
"/* Output the definition as an ordinary strong definition. */",
"/* We have already decided what to do with this DECL; there is no\n need to check anything further. */",
"/* The ABI requires that all virtual tables be emitted with\n\t COMDAT linkage. However, on systems where COMDAT symbols\n\t don't show up in the table of contents for a static\n\t archive, or on systems without weak symbols (where we\n\t approximate COMDAT linkage by using internal linkage), the\n\t linker will report errors about undefined symbols because\n\t it will not see the virtual table definition. Therefore,\n\t in the case that we know that the virtual table will be\n\t emitted in only one translation unit, we make the virtual\n\t table an ordinary definition with external linkage. */",
"/* CLASS_TYPE is being exported from this translation unit,\n\t so DECL should be defined here. */",
"/* If a class is declared in a header with the \"extern\n\t template\" extension, then it will not be instantiated,\n\t even in translation units that would normally require\n\t it. Often such classes are explicitly instantiated in\n\t one translation unit. Therefore, the explicit\n\t instantiation must be made visible to other translation\n\t units. */",
"/* The generic C++ ABI says that class data is always\n\t\t COMDAT, even if there is a key function. Some\n\t\t variants (e.g., the ARM EABI) says that class data\n\t\t only has COMDAT linkage if the class data might be\n\t\t emitted in more than one translation unit. When the\n\t\t key method can be inline and is inline, we still have\n\t\t to arrange for comdat even though\n\t\t class_data_always_comdat is false. */",
"/* The ABI requires COMDAT linkage. Normally, we\n\t\t only emit COMDAT things when they are needed;\n\t\t make sure that we realize that this entity is\n\t\t indeed needed. */",
"/* If -fno-rtti was specified, then we cannot be sure\n\t\t that RTTI information will be emitted with the\n\t\t virtual table of the class, so we must emit it\n\t\t wherever it is used. */",
"/* DECL is an implicit instantiation of a function or static\n\t data member. */",
"/* If we are not implicitly generating templates, then mark\n\t this entity as undefined in this translation unit. */",
"/* Always make artificials weak. */",
"/* If we are importing DECL into this translation unit, mark is\n\t an undefined here. */",
"/* If we decided to put DECL in COMDAT, mark it accordingly at\n\t this point. */"
] | [
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | build_cleanup | tree | tree
build_cleanup (tree decl)
{
tree temp;
tree type = TREE_TYPE (decl);
/* This function should only be called for declarations that really
require cleanups. */
gcc_assert (!TYPE_HAS_TRIVIAL_DESTRUCTOR (type));
/* Treat all objects with destructors as used; the destructor may do
something substantive. */
mark_used (decl);
if (TREE_CODE (type) == ARRAY_TYPE)
temp = decl;
else
temp = build_address (decl);
temp = build_delete (TREE_TYPE (temp), temp,
sfk_complete_destructor,
LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0,
tf_warning_or_error);
return temp;
} | /* Return an expression that performs the destruction of DECL, which
must be a VAR_DECL whose type has a non-trivial destructor, or is
an array whose (innermost) elements have a non-trivial destructor. */ | Return an expression that performs the destruction of DECL, which
must be a VAR_DECL whose type has a non-trivial destructor, or is
an array whose (innermost) elements have a non-trivial destructor. | [
"Return",
"an",
"expression",
"that",
"performs",
"the",
"destruction",
"of",
"DECL",
"which",
"must",
"be",
"a",
"VAR_DECL",
"whose",
"type",
"has",
"a",
"non",
"-",
"trivial",
"destructor",
"or",
"is",
"an",
"array",
"whose",
"(",
"innermost",
")",
"elements",
"have",
"a",
"non",
"-",
"trivial",
"destructor",
"."
] | tree
build_cleanup (tree decl)
{
tree temp;
tree type = TREE_TYPE (decl);
gcc_assert (!TYPE_HAS_TRIVIAL_DESTRUCTOR (type));
mark_used (decl);
if (TREE_CODE (type) == ARRAY_TYPE)
temp = decl;
else
temp = build_address (decl);
temp = build_delete (TREE_TYPE (temp), temp,
sfk_complete_destructor,
LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0,
tf_warning_or_error);
return temp;
} | [
"tree",
"build_cleanup",
"(",
"tree",
"decl",
")",
"{",
"tree",
"temp",
";",
"tree",
"type",
"=",
"TREE_TYPE",
"(",
"decl",
")",
";",
"gcc_assert",
"(",
"!",
"TYPE_HAS_TRIVIAL_DESTRUCTOR",
"(",
"type",
")",
")",
";",
"mark_used",
"(",
"decl",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"ARRAY_TYPE",
")",
"temp",
"=",
"decl",
";",
"else",
"temp",
"=",
"build_address",
"(",
"decl",
")",
";",
"temp",
"=",
"build_delete",
"(",
"TREE_TYPE",
"(",
"temp",
")",
",",
"temp",
",",
"sfk_complete_destructor",
",",
"LOOKUP_NORMAL",
"|",
"LOOKUP_NONVIRTUAL",
"|",
"LOOKUP_DESTRUCTOR",
",",
"0",
",",
"tf_warning_or_error",
")",
";",
"return",
"temp",
";",
"}"
] | Return an expression that performs the destruction of DECL, which
must be a VAR_DECL whose type has a non-trivial destructor, or is
an array whose (innermost) elements have a non-trivial destructor. | [
"Return",
"an",
"expression",
"that",
"performs",
"the",
"destruction",
"of",
"DECL",
"which",
"must",
"be",
"a",
"VAR_DECL",
"whose",
"type",
"has",
"a",
"non",
"-",
"trivial",
"destructor",
"or",
"is",
"an",
"array",
"whose",
"(",
"innermost",
")",
"elements",
"have",
"a",
"non",
"-",
"trivial",
"destructor",
"."
] | [
"/* This function should only be called for declarations that really\n require cleanups. */",
"/* Treat all objects with destructors as used; the destructor may do\n something substantive. */"
] | [
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | start_objects | tree | static tree
start_objects (int method_type, int initp)
{
tree body;
tree fndecl;
char type[14];
/* Make ctor or dtor function. METHOD_TYPE may be 'I' or 'D'. */
if (initp != DEFAULT_INIT_PRIORITY)
{
char joiner;
#ifdef JOINER
joiner = JOINER;
#else
joiner = '_';
#endif
sprintf (type, "sub_%c%c%.5u", method_type, joiner, initp);
}
else
sprintf (type, "sub_%c", method_type);
fndecl = build_lang_decl (FUNCTION_DECL,
get_file_function_name (type),
build_function_type_list (void_type_node,
NULL_TREE));
start_preparsed_function (fndecl, /*attrs=*/NULL_TREE, SF_PRE_PARSED);
TREE_PUBLIC (current_function_decl) = 0;
/* Mark as artificial because it's not explicitly in the user's
source code. */
DECL_ARTIFICIAL (current_function_decl) = 1;
/* Mark this declaration as used to avoid spurious warnings. */
TREE_USED (current_function_decl) = 1;
/* Mark this function as a global constructor or destructor. */
if (method_type == 'I')
DECL_GLOBAL_CTOR_P (current_function_decl) = 1;
else
DECL_GLOBAL_DTOR_P (current_function_decl) = 1;
body = begin_compound_stmt (BCS_FN_BODY);
return body;
} | /* Start the process of running a particular set of global constructors
or destructors. Subroutine of do_[cd]tors. */ | Start the process of running a particular set of global constructors
or destructors. Subroutine of do_[cd]tors. | [
"Start",
"the",
"process",
"of",
"running",
"a",
"particular",
"set",
"of",
"global",
"constructors",
"or",
"destructors",
".",
"Subroutine",
"of",
"do_",
"[",
"cd",
"]",
"tors",
"."
] | static tree
start_objects (int method_type, int initp)
{
tree body;
tree fndecl;
char type[14];
if (initp != DEFAULT_INIT_PRIORITY)
{
char joiner;
#ifdef JOINER
joiner = JOINER;
#else
joiner = '_';
#endif
sprintf (type, "sub_%c%c%.5u", method_type, joiner, initp);
}
else
sprintf (type, "sub_%c", method_type);
fndecl = build_lang_decl (FUNCTION_DECL,
get_file_function_name (type),
build_function_type_list (void_type_node,
NULL_TREE));
start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
TREE_PUBLIC (current_function_decl) = 0;
DECL_ARTIFICIAL (current_function_decl) = 1;
TREE_USED (current_function_decl) = 1;
if (method_type == 'I')
DECL_GLOBAL_CTOR_P (current_function_decl) = 1;
else
DECL_GLOBAL_DTOR_P (current_function_decl) = 1;
body = begin_compound_stmt (BCS_FN_BODY);
return body;
} | [
"static",
"tree",
"start_objects",
"(",
"int",
"method_type",
",",
"int",
"initp",
")",
"{",
"tree",
"body",
";",
"tree",
"fndecl",
";",
"char",
"type",
"[",
"14",
"]",
";",
"if",
"(",
"initp",
"!=",
"DEFAULT_INIT_PRIORITY",
")",
"{",
"char",
"joiner",
";",
"#ifdef",
"JOINER",
"joiner",
"=",
"JOINER",
";",
"#else",
"joiner",
"=",
"'",
"'",
";",
"#endif",
"sprintf",
"(",
"type",
",",
"\"",
"\"",
",",
"method_type",
",",
"joiner",
",",
"initp",
")",
";",
"}",
"else",
"sprintf",
"(",
"type",
",",
"\"",
"\"",
",",
"method_type",
")",
";",
"fndecl",
"=",
"build_lang_decl",
"(",
"FUNCTION_DECL",
",",
"get_file_function_name",
"(",
"type",
")",
",",
"build_function_type_list",
"(",
"void_type_node",
",",
"NULL_TREE",
")",
")",
";",
"start_preparsed_function",
"(",
"fndecl",
",",
"NULL_TREE",
",",
"SF_PRE_PARSED",
")",
";",
"TREE_PUBLIC",
"(",
"current_function_decl",
")",
"=",
"0",
";",
"DECL_ARTIFICIAL",
"(",
"current_function_decl",
")",
"=",
"1",
";",
"TREE_USED",
"(",
"current_function_decl",
")",
"=",
"1",
";",
"if",
"(",
"method_type",
"==",
"'",
"'",
")",
"DECL_GLOBAL_CTOR_P",
"(",
"current_function_decl",
")",
"=",
"1",
";",
"else",
"DECL_GLOBAL_DTOR_P",
"(",
"current_function_decl",
")",
"=",
"1",
";",
"body",
"=",
"begin_compound_stmt",
"(",
"BCS_FN_BODY",
")",
";",
"return",
"body",
";",
"}"
] | Start the process of running a particular set of global constructors
or destructors. | [
"Start",
"the",
"process",
"of",
"running",
"a",
"particular",
"set",
"of",
"global",
"constructors",
"or",
"destructors",
"."
] | [
"/* Make ctor or dtor function. METHOD_TYPE may be 'I' or 'D'. */",
"/*attrs=*/",
"/* Mark as artificial because it's not explicitly in the user's\n source code. */",
"/* Mark this declaration as used to avoid spurious warnings. */",
"/* Mark this function as a global constructor or destructor. */"
] | [
{
"param": "method_type",
"type": "int"
},
{
"param": "initp",
"type": "int"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "method_type",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "initp",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | finish_objects | void | static void
finish_objects (int method_type, int initp, tree body)
{
tree fn;
/* Finish up. */
finish_compound_stmt (body);
fn = finish_function (0);
if (method_type == 'I')
{
DECL_STATIC_CONSTRUCTOR (fn) = 1;
decl_init_priority_insert (fn, initp);
}
else
{
DECL_STATIC_DESTRUCTOR (fn) = 1;
decl_fini_priority_insert (fn, initp);
}
expand_or_defer_fn (fn);
} | /* Finish the process of running a particular set of global constructors
or destructors. Subroutine of do_[cd]tors. */ | Finish the process of running a particular set of global constructors
or destructors. Subroutine of do_[cd]tors. | [
"Finish",
"the",
"process",
"of",
"running",
"a",
"particular",
"set",
"of",
"global",
"constructors",
"or",
"destructors",
".",
"Subroutine",
"of",
"do_",
"[",
"cd",
"]",
"tors",
"."
] | static void
finish_objects (int method_type, int initp, tree body)
{
tree fn;
finish_compound_stmt (body);
fn = finish_function (0);
if (method_type == 'I')
{
DECL_STATIC_CONSTRUCTOR (fn) = 1;
decl_init_priority_insert (fn, initp);
}
else
{
DECL_STATIC_DESTRUCTOR (fn) = 1;
decl_fini_priority_insert (fn, initp);
}
expand_or_defer_fn (fn);
} | [
"static",
"void",
"finish_objects",
"(",
"int",
"method_type",
",",
"int",
"initp",
",",
"tree",
"body",
")",
"{",
"tree",
"fn",
";",
"finish_compound_stmt",
"(",
"body",
")",
";",
"fn",
"=",
"finish_function",
"(",
"0",
")",
";",
"if",
"(",
"method_type",
"==",
"'",
"'",
")",
"{",
"DECL_STATIC_CONSTRUCTOR",
"(",
"fn",
")",
"=",
"1",
";",
"decl_init_priority_insert",
"(",
"fn",
",",
"initp",
")",
";",
"}",
"else",
"{",
"DECL_STATIC_DESTRUCTOR",
"(",
"fn",
")",
"=",
"1",
";",
"decl_fini_priority_insert",
"(",
"fn",
",",
"initp",
")",
";",
"}",
"expand_or_defer_fn",
"(",
"fn",
")",
";",
"}"
] | Finish the process of running a particular set of global constructors
or destructors. | [
"Finish",
"the",
"process",
"of",
"running",
"a",
"particular",
"set",
"of",
"global",
"constructors",
"or",
"destructors",
"."
] | [
"/* Finish up. */"
] | [
{
"param": "method_type",
"type": "int"
},
{
"param": "initp",
"type": "int"
},
{
"param": "body",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "method_type",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "initp",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "body",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | start_static_storage_duration_function | tree | static tree
start_static_storage_duration_function (unsigned count)
{
tree type;
tree body;
char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32];
/* Create the identifier for this function. It will be of the form
SSDF_IDENTIFIER_<number>. */
sprintf (id, "%s_%u", SSDF_IDENTIFIER, count);
type = build_function_type_list (void_type_node,
integer_type_node, integer_type_node,
NULL_TREE);
/* Create the FUNCTION_DECL itself. */
ssdf_decl = build_lang_decl (FUNCTION_DECL,
get_identifier (id),
type);
TREE_PUBLIC (ssdf_decl) = 0;
DECL_ARTIFICIAL (ssdf_decl) = 1;
/* Put this function in the list of functions to be called from the
static constructors and destructors. */
if (!ssdf_decls)
{
ssdf_decls = VEC_alloc (tree, gc, 32);
/* Take this opportunity to initialize the map from priority
numbers to information about that priority level. */
priority_info_map = splay_tree_new (splay_tree_compare_ints,
/*delete_key_fn=*/0,
/*delete_value_fn=*/
(splay_tree_delete_value_fn) &free);
/* We always need to generate functions for the
DEFAULT_INIT_PRIORITY so enter it now. That way when we walk
priorities later, we'll be sure to find the
DEFAULT_INIT_PRIORITY. */
get_priority_info (DEFAULT_INIT_PRIORITY);
}
VEC_safe_push (tree, gc, ssdf_decls, ssdf_decl);
/* Create the argument list. */
initialize_p_decl = cp_build_parm_decl
(get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node);
DECL_CONTEXT (initialize_p_decl) = ssdf_decl;
TREE_USED (initialize_p_decl) = 1;
priority_decl = cp_build_parm_decl
(get_identifier (PRIORITY_IDENTIFIER), integer_type_node);
DECL_CONTEXT (priority_decl) = ssdf_decl;
TREE_USED (priority_decl) = 1;
DECL_CHAIN (initialize_p_decl) = priority_decl;
DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl;
/* Put the function in the global scope. */
pushdecl (ssdf_decl);
/* Start the function itself. This is equivalent to declaring the
function as:
static void __ssdf (int __initialize_p, init __priority_p);
It is static because we only need to call this function from the
various constructor and destructor functions for this module. */
start_preparsed_function (ssdf_decl,
/*attrs=*/NULL_TREE,
SF_PRE_PARSED);
/* Set up the scope of the outermost block in the function. */
body = begin_compound_stmt (BCS_FN_BODY);
return body;
} | /* Begins the generation of the function that will handle all
initialization and destruction of objects with static storage
duration. The function generated takes two parameters of type
`int': __INITIALIZE_P and __PRIORITY. If __INITIALIZE_P is
nonzero, it performs initializations. Otherwise, it performs
destructions. It only performs those initializations or
destructions with the indicated __PRIORITY. The generated function
returns no value.
It is assumed that this function will only be called once per
translation unit. */ | Begins the generation of the function that will handle all
initialization and destruction of objects with static storage
duration. The function generated takes two parameters of type
`int': __INITIALIZE_P and __PRIORITY. If __INITIALIZE_P is
nonzero, it performs initializations. Otherwise, it performs
destructions. It only performs those initializations or
destructions with the indicated __PRIORITY. The generated function
returns no value.
It is assumed that this function will only be called once per
translation unit. | [
"Begins",
"the",
"generation",
"of",
"the",
"function",
"that",
"will",
"handle",
"all",
"initialization",
"and",
"destruction",
"of",
"objects",
"with",
"static",
"storage",
"duration",
".",
"The",
"function",
"generated",
"takes",
"two",
"parameters",
"of",
"type",
"`",
"int",
"'",
":",
"__INITIALIZE_P",
"and",
"__PRIORITY",
".",
"If",
"__INITIALIZE_P",
"is",
"nonzero",
"it",
"performs",
"initializations",
".",
"Otherwise",
"it",
"performs",
"destructions",
".",
"It",
"only",
"performs",
"those",
"initializations",
"or",
"destructions",
"with",
"the",
"indicated",
"__PRIORITY",
".",
"The",
"generated",
"function",
"returns",
"no",
"value",
".",
"It",
"is",
"assumed",
"that",
"this",
"function",
"will",
"only",
"be",
"called",
"once",
"per",
"translation",
"unit",
"."
] | static tree
start_static_storage_duration_function (unsigned count)
{
tree type;
tree body;
char id[sizeof (SSDF_IDENTIFIER) + 1 + 32];
sprintf (id, "%s_%u", SSDF_IDENTIFIER, count);
type = build_function_type_list (void_type_node,
integer_type_node, integer_type_node,
NULL_TREE);
ssdf_decl = build_lang_decl (FUNCTION_DECL,
get_identifier (id),
type);
TREE_PUBLIC (ssdf_decl) = 0;
DECL_ARTIFICIAL (ssdf_decl) = 1;
if (!ssdf_decls)
{
ssdf_decls = VEC_alloc (tree, gc, 32);
priority_info_map = splay_tree_new (splay_tree_compare_ints,
0,
(splay_tree_delete_value_fn) &free);
get_priority_info (DEFAULT_INIT_PRIORITY);
}
VEC_safe_push (tree, gc, ssdf_decls, ssdf_decl);
initialize_p_decl = cp_build_parm_decl
(get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node);
DECL_CONTEXT (initialize_p_decl) = ssdf_decl;
TREE_USED (initialize_p_decl) = 1;
priority_decl = cp_build_parm_decl
(get_identifier (PRIORITY_IDENTIFIER), integer_type_node);
DECL_CONTEXT (priority_decl) = ssdf_decl;
TREE_USED (priority_decl) = 1;
DECL_CHAIN (initialize_p_decl) = priority_decl;
DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl;
pushdecl (ssdf_decl);
start_preparsed_function (ssdf_decl,
NULL_TREE,
SF_PRE_PARSED);
body = begin_compound_stmt (BCS_FN_BODY);
return body;
} | [
"static",
"tree",
"start_static_storage_duration_function",
"(",
"unsigned",
"count",
")",
"{",
"tree",
"type",
";",
"tree",
"body",
";",
"char",
"id",
"[",
"sizeof",
"(",
"SSDF_IDENTIFIER",
")",
"+",
"1",
"+",
"32",
"]",
";",
"sprintf",
"(",
"id",
",",
"\"",
"\"",
",",
"SSDF_IDENTIFIER",
",",
"count",
")",
";",
"type",
"=",
"build_function_type_list",
"(",
"void_type_node",
",",
"integer_type_node",
",",
"integer_type_node",
",",
"NULL_TREE",
")",
";",
"ssdf_decl",
"=",
"build_lang_decl",
"(",
"FUNCTION_DECL",
",",
"get_identifier",
"(",
"id",
")",
",",
"type",
")",
";",
"TREE_PUBLIC",
"(",
"ssdf_decl",
")",
"=",
"0",
";",
"DECL_ARTIFICIAL",
"(",
"ssdf_decl",
")",
"=",
"1",
";",
"if",
"(",
"!",
"ssdf_decls",
")",
"{",
"ssdf_decls",
"=",
"VEC_alloc",
"(",
"tree",
",",
"gc",
",",
"32",
")",
";",
"priority_info_map",
"=",
"splay_tree_new",
"(",
"splay_tree_compare_ints",
",",
"0",
",",
"(",
"splay_tree_delete_value_fn",
")",
"&",
"free",
")",
";",
"get_priority_info",
"(",
"DEFAULT_INIT_PRIORITY",
")",
";",
"}",
"VEC_safe_push",
"(",
"tree",
",",
"gc",
",",
"ssdf_decls",
",",
"ssdf_decl",
")",
";",
"initialize_p_decl",
"=",
"cp_build_parm_decl",
"(",
"get_identifier",
"(",
"INITIALIZE_P_IDENTIFIER",
")",
",",
"integer_type_node",
")",
";",
"DECL_CONTEXT",
"(",
"initialize_p_decl",
")",
"=",
"ssdf_decl",
";",
"TREE_USED",
"(",
"initialize_p_decl",
")",
"=",
"1",
";",
"priority_decl",
"=",
"cp_build_parm_decl",
"(",
"get_identifier",
"(",
"PRIORITY_IDENTIFIER",
")",
",",
"integer_type_node",
")",
";",
"DECL_CONTEXT",
"(",
"priority_decl",
")",
"=",
"ssdf_decl",
";",
"TREE_USED",
"(",
"priority_decl",
")",
"=",
"1",
";",
"DECL_CHAIN",
"(",
"initialize_p_decl",
")",
"=",
"priority_decl",
";",
"DECL_ARGUMENTS",
"(",
"ssdf_decl",
")",
"=",
"initialize_p_decl",
";",
"pushdecl",
"(",
"ssdf_decl",
")",
";",
"start_preparsed_function",
"(",
"ssdf_decl",
",",
"NULL_TREE",
",",
"SF_PRE_PARSED",
")",
";",
"body",
"=",
"begin_compound_stmt",
"(",
"BCS_FN_BODY",
")",
";",
"return",
"body",
";",
"}"
] | Begins the generation of the function that will handle all
initialization and destruction of objects with static storage
duration. | [
"Begins",
"the",
"generation",
"of",
"the",
"function",
"that",
"will",
"handle",
"all",
"initialization",
"and",
"destruction",
"of",
"objects",
"with",
"static",
"storage",
"duration",
"."
] | [
"/* '\\0' */",
"/* Create the identifier for this function. It will be of the form\n SSDF_IDENTIFIER_<number>. */",
"/* Create the FUNCTION_DECL itself. */",
"/* Put this function in the list of functions to be called from the\n static constructors and destructors. */",
"/* Take this opportunity to initialize the map from priority\n\t numbers to information about that priority level. */",
"/*delete_key_fn=*/",
"/*delete_value_fn=*/",
"/* We always need to generate functions for the\n\t DEFAULT_INIT_PRIORITY so enter it now. That way when we walk\n\t priorities later, we'll be sure to find the\n\t DEFAULT_INIT_PRIORITY. */",
"/* Create the argument list. */",
"/* Put the function in the global scope. */",
"/* Start the function itself. This is equivalent to declaring the\n function as:\n\n static void __ssdf (int __initialize_p, init __priority_p);\n\n It is static because we only need to call this function from the\n various constructor and destructor functions for this module. */",
"/*attrs=*/",
"/* Set up the scope of the outermost block in the function. */"
] | [
{
"param": "count",
"type": "unsigned"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "count",
"type": "unsigned",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | finish_static_storage_duration_function | void | static void
finish_static_storage_duration_function (tree body)
{
/* Close out the function. */
finish_compound_stmt (body);
expand_or_defer_fn (finish_function (0));
} | /* Finish the generation of the function which performs initialization
and destruction of objects with static storage duration. After
this point, no more such objects can be created. */ | Finish the generation of the function which performs initialization
and destruction of objects with static storage duration. After
this point, no more such objects can be created. | [
"Finish",
"the",
"generation",
"of",
"the",
"function",
"which",
"performs",
"initialization",
"and",
"destruction",
"of",
"objects",
"with",
"static",
"storage",
"duration",
".",
"After",
"this",
"point",
"no",
"more",
"such",
"objects",
"can",
"be",
"created",
"."
] | static void
finish_static_storage_duration_function (tree body)
{
finish_compound_stmt (body);
expand_or_defer_fn (finish_function (0));
} | [
"static",
"void",
"finish_static_storage_duration_function",
"(",
"tree",
"body",
")",
"{",
"finish_compound_stmt",
"(",
"body",
")",
";",
"expand_or_defer_fn",
"(",
"finish_function",
"(",
"0",
")",
")",
";",
"}"
] | Finish the generation of the function which performs initialization
and destruction of objects with static storage duration. | [
"Finish",
"the",
"generation",
"of",
"the",
"function",
"which",
"performs",
"initialization",
"and",
"destruction",
"of",
"objects",
"with",
"static",
"storage",
"duration",
"."
] | [
"/* Close out the function. */"
] | [
{
"param": "body",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "body",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | one_static_initialization_or_destruction | void | static void
one_static_initialization_or_destruction (tree decl, tree init, bool initp)
{
tree guard_if_stmt = NULL_TREE;
tree guard;
/* If we are supposed to destruct and there's a trivial destructor,
nothing has to be done. */
if (!initp
&& TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
return;
/* Trick the compiler into thinking we are at the file and line
where DECL was declared so that error-messages make sense, and so
that the debugger will show somewhat sensible file and line
information. */
input_location = DECL_SOURCE_LOCATION (decl);
/* Make sure temporary variables in the initialiser all have
their DECL_CONTEXT() set to a value different from NULL_TREE.
This can happen when global variables initialisers are built.
In that case, the DECL_CONTEXT() of the global variables _AND_ of all
the temporary variables that might have been generated in the
accompagning initialisers is NULL_TREE, meaning the variables have been
declared in the global namespace.
What we want to do here is to fix that and make sure the DECL_CONTEXT()
of the temporaries are set to the current function decl. */
cp_walk_tree_without_duplicates (&init,
fix_temporary_vars_context_r,
NULL);
/* Because of:
[class.access.spec]
Access control for implicit calls to the constructors,
the conversion functions, or the destructor called to
create and destroy a static data member is performed as
if these calls appeared in the scope of the member's
class.
we pretend we are in a static member function of the class of
which the DECL is a member. */
if (member_p (decl))
{
DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
}
/* Assume we don't need a guard. */
guard = NULL_TREE;
/* We need a guard if this is an object with external linkage that
might be initialized in more than one place. (For example, a
static data member of a template, when the data member requires
construction.) */
if (NEEDS_GUARD_P (decl))
{
tree guard_cond;
guard = get_guard (decl);
/* When using __cxa_atexit, we just check the GUARD as we would
for a local static. */
if (flag_use_cxa_atexit)
{
/* When using __cxa_atexit, we never try to destroy
anything from a static destructor. */
gcc_assert (initp);
guard_cond = get_guard_cond (guard);
}
/* If we don't have __cxa_atexit, then we will be running
destructors from .fini sections, or their equivalents. So,
we need to know how many times we've tried to initialize this
object. We do initializations only if the GUARD is zero,
i.e., if we are the first to initialize the variable. We do
destructions only if the GUARD is one, i.e., if we are the
last to destroy the variable. */
else if (initp)
guard_cond
= cp_build_binary_op (input_location,
EQ_EXPR,
cp_build_unary_op (PREINCREMENT_EXPR,
guard,
/*noconvert=*/1,
tf_warning_or_error),
integer_one_node,
tf_warning_or_error);
else
guard_cond
= cp_build_binary_op (input_location,
EQ_EXPR,
cp_build_unary_op (PREDECREMENT_EXPR,
guard,
/*noconvert=*/1,
tf_warning_or_error),
integer_zero_node,
tf_warning_or_error);
guard_if_stmt = begin_if_stmt ();
finish_if_stmt_cond (guard_cond, guard_if_stmt);
}
/* If we're using __cxa_atexit, we have not already set the GUARD,
so we must do so now. */
if (guard && initp && flag_use_cxa_atexit)
finish_expr_stmt (set_guard (guard));
/* Perform the initialization or destruction. */
if (initp)
{
if (init)
finish_expr_stmt (init);
/* If we're using __cxa_atexit, register a function that calls the
destructor for the object. */
if (flag_use_cxa_atexit)
finish_expr_stmt (register_dtor_fn (decl));
}
else
finish_expr_stmt (build_cleanup (decl));
/* Finish the guard if-stmt, if necessary. */
if (guard)
{
finish_then_clause (guard_if_stmt);
finish_if_stmt (guard_if_stmt);
}
/* Now that we're done with DECL we don't need to pretend to be a
member of its class any longer. */
DECL_CONTEXT (current_function_decl) = NULL_TREE;
DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
} | /* Set up to handle the initialization or destruction of DECL. If
INITP is nonzero, we are initializing the variable. Otherwise, we
are destroying it. */ | Set up to handle the initialization or destruction of DECL. If
INITP is nonzero, we are initializing the variable. Otherwise, we
are destroying it. | [
"Set",
"up",
"to",
"handle",
"the",
"initialization",
"or",
"destruction",
"of",
"DECL",
".",
"If",
"INITP",
"is",
"nonzero",
"we",
"are",
"initializing",
"the",
"variable",
".",
"Otherwise",
"we",
"are",
"destroying",
"it",
"."
] | static void
one_static_initialization_or_destruction (tree decl, tree init, bool initp)
{
tree guard_if_stmt = NULL_TREE;
tree guard;
if (!initp
&& TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
return;
input_location = DECL_SOURCE_LOCATION (decl);
cp_walk_tree_without_duplicates (&init,
fix_temporary_vars_context_r,
NULL);
if (member_p (decl))
{
DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
}
guard = NULL_TREE;
if (NEEDS_GUARD_P (decl))
{
tree guard_cond;
guard = get_guard (decl);
if (flag_use_cxa_atexit)
{
gcc_assert (initp);
guard_cond = get_guard_cond (guard);
}
else if (initp)
guard_cond
= cp_build_binary_op (input_location,
EQ_EXPR,
cp_build_unary_op (PREINCREMENT_EXPR,
guard,
1,
tf_warning_or_error),
integer_one_node,
tf_warning_or_error);
else
guard_cond
= cp_build_binary_op (input_location,
EQ_EXPR,
cp_build_unary_op (PREDECREMENT_EXPR,
guard,
1,
tf_warning_or_error),
integer_zero_node,
tf_warning_or_error);
guard_if_stmt = begin_if_stmt ();
finish_if_stmt_cond (guard_cond, guard_if_stmt);
}
if (guard && initp && flag_use_cxa_atexit)
finish_expr_stmt (set_guard (guard));
if (initp)
{
if (init)
finish_expr_stmt (init);
if (flag_use_cxa_atexit)
finish_expr_stmt (register_dtor_fn (decl));
}
else
finish_expr_stmt (build_cleanup (decl));
if (guard)
{
finish_then_clause (guard_if_stmt);
finish_if_stmt (guard_if_stmt);
}
DECL_CONTEXT (current_function_decl) = NULL_TREE;
DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
} | [
"static",
"void",
"one_static_initialization_or_destruction",
"(",
"tree",
"decl",
",",
"tree",
"init",
",",
"bool",
"initp",
")",
"{",
"tree",
"guard_if_stmt",
"=",
"NULL_TREE",
";",
"tree",
"guard",
";",
"if",
"(",
"!",
"initp",
"&&",
"TYPE_HAS_TRIVIAL_DESTRUCTOR",
"(",
"TREE_TYPE",
"(",
"decl",
")",
")",
")",
"return",
";",
"input_location",
"=",
"DECL_SOURCE_LOCATION",
"(",
"decl",
")",
";",
"cp_walk_tree_without_duplicates",
"(",
"&",
"init",
",",
"fix_temporary_vars_context_r",
",",
"NULL",
")",
";",
"if",
"(",
"member_p",
"(",
"decl",
")",
")",
"{",
"DECL_CONTEXT",
"(",
"current_function_decl",
")",
"=",
"DECL_CONTEXT",
"(",
"decl",
")",
";",
"DECL_STATIC_FUNCTION_P",
"(",
"current_function_decl",
")",
"=",
"1",
";",
"}",
"guard",
"=",
"NULL_TREE",
";",
"if",
"(",
"NEEDS_GUARD_P",
"(",
"decl",
")",
")",
"{",
"tree",
"guard_cond",
";",
"guard",
"=",
"get_guard",
"(",
"decl",
")",
";",
"if",
"(",
"flag_use_cxa_atexit",
")",
"{",
"gcc_assert",
"(",
"initp",
")",
";",
"guard_cond",
"=",
"get_guard_cond",
"(",
"guard",
")",
";",
"}",
"else",
"if",
"(",
"initp",
")",
"guard_cond",
"=",
"cp_build_binary_op",
"(",
"input_location",
",",
"EQ_EXPR",
",",
"cp_build_unary_op",
"(",
"PREINCREMENT_EXPR",
",",
"guard",
",",
"1",
",",
"tf_warning_or_error",
")",
",",
"integer_one_node",
",",
"tf_warning_or_error",
")",
";",
"else",
"guard_cond",
"=",
"cp_build_binary_op",
"(",
"input_location",
",",
"EQ_EXPR",
",",
"cp_build_unary_op",
"(",
"PREDECREMENT_EXPR",
",",
"guard",
",",
"1",
",",
"tf_warning_or_error",
")",
",",
"integer_zero_node",
",",
"tf_warning_or_error",
")",
";",
"guard_if_stmt",
"=",
"begin_if_stmt",
"(",
")",
";",
"finish_if_stmt_cond",
"(",
"guard_cond",
",",
"guard_if_stmt",
")",
";",
"}",
"if",
"(",
"guard",
"&&",
"initp",
"&&",
"flag_use_cxa_atexit",
")",
"finish_expr_stmt",
"(",
"set_guard",
"(",
"guard",
")",
")",
";",
"if",
"(",
"initp",
")",
"{",
"if",
"(",
"init",
")",
"finish_expr_stmt",
"(",
"init",
")",
";",
"if",
"(",
"flag_use_cxa_atexit",
")",
"finish_expr_stmt",
"(",
"register_dtor_fn",
"(",
"decl",
")",
")",
";",
"}",
"else",
"finish_expr_stmt",
"(",
"build_cleanup",
"(",
"decl",
")",
")",
";",
"if",
"(",
"guard",
")",
"{",
"finish_then_clause",
"(",
"guard_if_stmt",
")",
";",
"finish_if_stmt",
"(",
"guard_if_stmt",
")",
";",
"}",
"DECL_CONTEXT",
"(",
"current_function_decl",
")",
"=",
"NULL_TREE",
";",
"DECL_STATIC_FUNCTION_P",
"(",
"current_function_decl",
")",
"=",
"0",
";",
"}"
] | Set up to handle the initialization or destruction of DECL. | [
"Set",
"up",
"to",
"handle",
"the",
"initialization",
"or",
"destruction",
"of",
"DECL",
"."
] | [
"/* If we are supposed to destruct and there's a trivial destructor,\n nothing has to be done. */",
"/* Trick the compiler into thinking we are at the file and line\n where DECL was declared so that error-messages make sense, and so\n that the debugger will show somewhat sensible file and line\n information. */",
"/* Make sure temporary variables in the initialiser all have\n their DECL_CONTEXT() set to a value different from NULL_TREE.\n This can happen when global variables initialisers are built.\n In that case, the DECL_CONTEXT() of the global variables _AND_ of all \n the temporary variables that might have been generated in the\n accompagning initialisers is NULL_TREE, meaning the variables have been\n declared in the global namespace.\n What we want to do here is to fix that and make sure the DECL_CONTEXT()\n of the temporaries are set to the current function decl. */",
"/* Because of:\n\n [class.access.spec]\n\n Access control for implicit calls to the constructors,\n the conversion functions, or the destructor called to\n create and destroy a static data member is performed as\n if these calls appeared in the scope of the member's\n class.\n\n we pretend we are in a static member function of the class of\n which the DECL is a member. */",
"/* Assume we don't need a guard. */",
"/* We need a guard if this is an object with external linkage that\n might be initialized in more than one place. (For example, a\n static data member of a template, when the data member requires\n construction.) */",
"/* When using __cxa_atexit, we just check the GUARD as we would\n\t for a local static. */",
"/* When using __cxa_atexit, we never try to destroy\n\t anything from a static destructor. */",
"/* If we don't have __cxa_atexit, then we will be running\n\t destructors from .fini sections, or their equivalents. So,\n\t we need to know how many times we've tried to initialize this\n\t object. We do initializations only if the GUARD is zero,\n\t i.e., if we are the first to initialize the variable. We do\n\t destructions only if the GUARD is one, i.e., if we are the\n\t last to destroy the variable. */",
"/*noconvert=*/",
"/*noconvert=*/",
"/* If we're using __cxa_atexit, we have not already set the GUARD,\n so we must do so now. */",
"/* Perform the initialization or destruction. */",
"/* If we're using __cxa_atexit, register a function that calls the\n\t destructor for the object. */",
"/* Finish the guard if-stmt, if necessary. */",
"/* Now that we're done with DECL we don't need to pretend to be a\n member of its class any longer. */"
] | [
{
"param": "decl",
"type": "tree"
},
{
"param": "init",
"type": "tree"
},
{
"param": "initp",
"type": "bool"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "init",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "initp",
"type": "bool",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | do_static_initialization_or_destruction | void | static void
do_static_initialization_or_destruction (tree vars, bool initp)
{
tree node, init_if_stmt, cond;
/* Build the outer if-stmt to check for initialization or destruction. */
init_if_stmt = begin_if_stmt ();
cond = initp ? integer_one_node : integer_zero_node;
cond = cp_build_binary_op (input_location,
EQ_EXPR,
initialize_p_decl,
cond,
tf_warning_or_error);
finish_if_stmt_cond (cond, init_if_stmt);
node = vars;
do {
tree decl = TREE_VALUE (node);
tree priority_if_stmt;
int priority;
priority_info pi;
/* If we don't need a destructor, there's nothing to do. Avoid
creating a possibly empty if-stmt. */
if (!initp && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
{
node = TREE_CHAIN (node);
continue;
}
/* Remember that we had an initialization or finalization at this
priority. */
priority = DECL_EFFECTIVE_INIT_PRIORITY (decl);
pi = get_priority_info (priority);
if (initp)
pi->initializations_p = 1;
else
pi->destructions_p = 1;
/* Conditionalize this initialization on being in the right priority
and being initializing/finalizing appropriately. */
priority_if_stmt = begin_if_stmt ();
cond = cp_build_binary_op (input_location,
EQ_EXPR,
priority_decl,
build_int_cst (NULL_TREE, priority),
tf_warning_or_error);
finish_if_stmt_cond (cond, priority_if_stmt);
/* Process initializers with same priority. */
for (; node
&& DECL_EFFECTIVE_INIT_PRIORITY (TREE_VALUE (node)) == priority;
node = TREE_CHAIN (node))
/* Do one initialization or destruction. */
one_static_initialization_or_destruction (TREE_VALUE (node),
TREE_PURPOSE (node), initp);
/* Finish up the priority if-stmt body. */
finish_then_clause (priority_if_stmt);
finish_if_stmt (priority_if_stmt);
} while (node);
/* Finish up the init/destruct if-stmt body. */
finish_then_clause (init_if_stmt);
finish_if_stmt (init_if_stmt);
} | /* Generate code to do the initialization or destruction of the decls in VARS,
a TREE_LIST of VAR_DECL with static storage duration.
Whether initialization or destruction is performed is specified by INITP. */ | Generate code to do the initialization or destruction of the decls in VARS,
a TREE_LIST of VAR_DECL with static storage duration.
Whether initialization or destruction is performed is specified by INITP. | [
"Generate",
"code",
"to",
"do",
"the",
"initialization",
"or",
"destruction",
"of",
"the",
"decls",
"in",
"VARS",
"a",
"TREE_LIST",
"of",
"VAR_DECL",
"with",
"static",
"storage",
"duration",
".",
"Whether",
"initialization",
"or",
"destruction",
"is",
"performed",
"is",
"specified",
"by",
"INITP",
"."
] | static void
do_static_initialization_or_destruction (tree vars, bool initp)
{
tree node, init_if_stmt, cond;
init_if_stmt = begin_if_stmt ();
cond = initp ? integer_one_node : integer_zero_node;
cond = cp_build_binary_op (input_location,
EQ_EXPR,
initialize_p_decl,
cond,
tf_warning_or_error);
finish_if_stmt_cond (cond, init_if_stmt);
node = vars;
do {
tree decl = TREE_VALUE (node);
tree priority_if_stmt;
int priority;
priority_info pi;
if (!initp && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
{
node = TREE_CHAIN (node);
continue;
}
priority = DECL_EFFECTIVE_INIT_PRIORITY (decl);
pi = get_priority_info (priority);
if (initp)
pi->initializations_p = 1;
else
pi->destructions_p = 1;
priority_if_stmt = begin_if_stmt ();
cond = cp_build_binary_op (input_location,
EQ_EXPR,
priority_decl,
build_int_cst (NULL_TREE, priority),
tf_warning_or_error);
finish_if_stmt_cond (cond, priority_if_stmt);
for (; node
&& DECL_EFFECTIVE_INIT_PRIORITY (TREE_VALUE (node)) == priority;
node = TREE_CHAIN (node))
one_static_initialization_or_destruction (TREE_VALUE (node),
TREE_PURPOSE (node), initp);
finish_then_clause (priority_if_stmt);
finish_if_stmt (priority_if_stmt);
} while (node);
finish_then_clause (init_if_stmt);
finish_if_stmt (init_if_stmt);
} | [
"static",
"void",
"do_static_initialization_or_destruction",
"(",
"tree",
"vars",
",",
"bool",
"initp",
")",
"{",
"tree",
"node",
",",
"init_if_stmt",
",",
"cond",
";",
"init_if_stmt",
"=",
"begin_if_stmt",
"(",
")",
";",
"cond",
"=",
"initp",
"?",
"integer_one_node",
":",
"integer_zero_node",
";",
"cond",
"=",
"cp_build_binary_op",
"(",
"input_location",
",",
"EQ_EXPR",
",",
"initialize_p_decl",
",",
"cond",
",",
"tf_warning_or_error",
")",
";",
"finish_if_stmt_cond",
"(",
"cond",
",",
"init_if_stmt",
")",
";",
"node",
"=",
"vars",
";",
"do",
"{",
"tree",
"decl",
"=",
"TREE_VALUE",
"(",
"node",
")",
";",
"tree",
"priority_if_stmt",
";",
"int",
"priority",
";",
"priority_info",
"pi",
";",
"if",
"(",
"!",
"initp",
"&&",
"TYPE_HAS_TRIVIAL_DESTRUCTOR",
"(",
"TREE_TYPE",
"(",
"decl",
")",
")",
")",
"{",
"node",
"=",
"TREE_CHAIN",
"(",
"node",
")",
";",
"continue",
";",
"}",
"priority",
"=",
"DECL_EFFECTIVE_INIT_PRIORITY",
"(",
"decl",
")",
";",
"pi",
"=",
"get_priority_info",
"(",
"priority",
")",
";",
"if",
"(",
"initp",
")",
"pi",
"->",
"initializations_p",
"=",
"1",
";",
"else",
"pi",
"->",
"destructions_p",
"=",
"1",
";",
"priority_if_stmt",
"=",
"begin_if_stmt",
"(",
")",
";",
"cond",
"=",
"cp_build_binary_op",
"(",
"input_location",
",",
"EQ_EXPR",
",",
"priority_decl",
",",
"build_int_cst",
"(",
"NULL_TREE",
",",
"priority",
")",
",",
"tf_warning_or_error",
")",
";",
"finish_if_stmt_cond",
"(",
"cond",
",",
"priority_if_stmt",
")",
";",
"for",
"(",
";",
"node",
"&&",
"DECL_EFFECTIVE_INIT_PRIORITY",
"(",
"TREE_VALUE",
"(",
"node",
")",
")",
"==",
"priority",
";",
"node",
"=",
"TREE_CHAIN",
"(",
"node",
")",
")",
"one_static_initialization_or_destruction",
"(",
"TREE_VALUE",
"(",
"node",
")",
",",
"TREE_PURPOSE",
"(",
"node",
")",
",",
"initp",
")",
";",
"finish_then_clause",
"(",
"priority_if_stmt",
")",
";",
"finish_if_stmt",
"(",
"priority_if_stmt",
")",
";",
"}",
"while",
"(",
"node",
")",
";",
"finish_then_clause",
"(",
"init_if_stmt",
")",
";",
"finish_if_stmt",
"(",
"init_if_stmt",
")",
";",
"}"
] | Generate code to do the initialization or destruction of the decls in VARS,
a TREE_LIST of VAR_DECL with static storage duration. | [
"Generate",
"code",
"to",
"do",
"the",
"initialization",
"or",
"destruction",
"of",
"the",
"decls",
"in",
"VARS",
"a",
"TREE_LIST",
"of",
"VAR_DECL",
"with",
"static",
"storage",
"duration",
"."
] | [
"/* Build the outer if-stmt to check for initialization or destruction. */",
"/* If we don't need a destructor, there's nothing to do. Avoid\n creating a possibly empty if-stmt. */",
"/* Remember that we had an initialization or finalization at this\n priority. */",
"/* Conditionalize this initialization on being in the right priority\n and being initializing/finalizing appropriately. */",
"/* Process initializers with same priority. */",
"/* Do one initialization or destruction. */",
"/* Finish up the priority if-stmt body. */",
"/* Finish up the init/destruct if-stmt body. */"
] | [
{
"param": "vars",
"type": "tree"
},
{
"param": "initp",
"type": "bool"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "vars",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "initp",
"type": "bool",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | prune_vars_needing_no_initialization | tree | static tree
prune_vars_needing_no_initialization (tree *vars)
{
tree *var = vars;
tree result = NULL_TREE;
while (*var)
{
tree t = *var;
tree decl = TREE_VALUE (t);
tree init = TREE_PURPOSE (t);
/* Deal gracefully with error. */
if (decl == error_mark_node)
{
var = &TREE_CHAIN (t);
continue;
}
/* The only things that can be initialized are variables. */
gcc_assert (TREE_CODE (decl) == VAR_DECL);
/* If this object is not defined, we don't need to do anything
here. */
if (DECL_EXTERNAL (decl))
{
var = &TREE_CHAIN (t);
continue;
}
/* Also, if the initializer already contains errors, we can bail
out now. */
if (init && TREE_CODE (init) == TREE_LIST
&& value_member (error_mark_node, init))
{
var = &TREE_CHAIN (t);
continue;
}
/* This variable is going to need initialization and/or
finalization, so we add it to the list. */
*var = TREE_CHAIN (t);
TREE_CHAIN (t) = result;
result = t;
}
return result;
} | /* VARS is a list of variables with static storage duration which may
need initialization and/or finalization. Remove those variables
that don't really need to be initialized or finalized, and return
the resulting list. The order in which the variables appear in
VARS is in reverse order of the order in which they should actually
be initialized. The list we return is in the unreversed order;
i.e., the first variable should be initialized first. */ | VARS is a list of variables with static storage duration which may
need initialization and/or finalization. Remove those variables
that don't really need to be initialized or finalized, and return
the resulting list. The order in which the variables appear in
VARS is in reverse order of the order in which they should actually
be initialized. The list we return is in the unreversed order;
i.e., the first variable should be initialized first. | [
"VARS",
"is",
"a",
"list",
"of",
"variables",
"with",
"static",
"storage",
"duration",
"which",
"may",
"need",
"initialization",
"and",
"/",
"or",
"finalization",
".",
"Remove",
"those",
"variables",
"that",
"don",
"'",
"t",
"really",
"need",
"to",
"be",
"initialized",
"or",
"finalized",
"and",
"return",
"the",
"resulting",
"list",
".",
"The",
"order",
"in",
"which",
"the",
"variables",
"appear",
"in",
"VARS",
"is",
"in",
"reverse",
"order",
"of",
"the",
"order",
"in",
"which",
"they",
"should",
"actually",
"be",
"initialized",
".",
"The",
"list",
"we",
"return",
"is",
"in",
"the",
"unreversed",
"order",
";",
"i",
".",
"e",
".",
"the",
"first",
"variable",
"should",
"be",
"initialized",
"first",
"."
] | static tree
prune_vars_needing_no_initialization (tree *vars)
{
tree *var = vars;
tree result = NULL_TREE;
while (*var)
{
tree t = *var;
tree decl = TREE_VALUE (t);
tree init = TREE_PURPOSE (t);
if (decl == error_mark_node)
{
var = &TREE_CHAIN (t);
continue;
}
gcc_assert (TREE_CODE (decl) == VAR_DECL);
if (DECL_EXTERNAL (decl))
{
var = &TREE_CHAIN (t);
continue;
}
if (init && TREE_CODE (init) == TREE_LIST
&& value_member (error_mark_node, init))
{
var = &TREE_CHAIN (t);
continue;
}
*var = TREE_CHAIN (t);
TREE_CHAIN (t) = result;
result = t;
}
return result;
} | [
"static",
"tree",
"prune_vars_needing_no_initialization",
"(",
"tree",
"*",
"vars",
")",
"{",
"tree",
"*",
"var",
"=",
"vars",
";",
"tree",
"result",
"=",
"NULL_TREE",
";",
"while",
"(",
"*",
"var",
")",
"{",
"tree",
"t",
"=",
"*",
"var",
";",
"tree",
"decl",
"=",
"TREE_VALUE",
"(",
"t",
")",
";",
"tree",
"init",
"=",
"TREE_PURPOSE",
"(",
"t",
")",
";",
"if",
"(",
"decl",
"==",
"error_mark_node",
")",
"{",
"var",
"=",
"&",
"TREE_CHAIN",
"(",
"t",
")",
";",
"continue",
";",
"}",
"gcc_assert",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"VAR_DECL",
")",
";",
"if",
"(",
"DECL_EXTERNAL",
"(",
"decl",
")",
")",
"{",
"var",
"=",
"&",
"TREE_CHAIN",
"(",
"t",
")",
";",
"continue",
";",
"}",
"if",
"(",
"init",
"&&",
"TREE_CODE",
"(",
"init",
")",
"==",
"TREE_LIST",
"&&",
"value_member",
"(",
"error_mark_node",
",",
"init",
")",
")",
"{",
"var",
"=",
"&",
"TREE_CHAIN",
"(",
"t",
")",
";",
"continue",
";",
"}",
"*",
"var",
"=",
"TREE_CHAIN",
"(",
"t",
")",
";",
"TREE_CHAIN",
"(",
"t",
")",
"=",
"result",
";",
"result",
"=",
"t",
";",
"}",
"return",
"result",
";",
"}"
] | VARS is a list of variables with static storage duration which may
need initialization and/or finalization. | [
"VARS",
"is",
"a",
"list",
"of",
"variables",
"with",
"static",
"storage",
"duration",
"which",
"may",
"need",
"initialization",
"and",
"/",
"or",
"finalization",
"."
] | [
"/* Deal gracefully with error. */",
"/* The only things that can be initialized are variables. */",
"/* If this object is not defined, we don't need to do anything\n\t here. */",
"/* Also, if the initializer already contains errors, we can bail\n\t out now. */",
"/* This variable is going to need initialization and/or\n\t finalization, so we add it to the list. */"
] | [
{
"param": "vars",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "vars",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | write_out_vars | void | static void
write_out_vars (tree vars)
{
tree v;
for (v = vars; v; v = TREE_CHAIN (v))
{
tree var = TREE_VALUE (v);
if (!var_finalized_p (var))
{
import_export_decl (var);
rest_of_decl_compilation (var, 1, 1);
}
}
} | /* Make sure we have told the back end about all the variables in
VARS. */ | Make sure we have told the back end about all the variables in
VARS. | [
"Make",
"sure",
"we",
"have",
"told",
"the",
"back",
"end",
"about",
"all",
"the",
"variables",
"in",
"VARS",
"."
] | static void
write_out_vars (tree vars)
{
tree v;
for (v = vars; v; v = TREE_CHAIN (v))
{
tree var = TREE_VALUE (v);
if (!var_finalized_p (var))
{
import_export_decl (var);
rest_of_decl_compilation (var, 1, 1);
}
}
} | [
"static",
"void",
"write_out_vars",
"(",
"tree",
"vars",
")",
"{",
"tree",
"v",
";",
"for",
"(",
"v",
"=",
"vars",
";",
"v",
";",
"v",
"=",
"TREE_CHAIN",
"(",
"v",
")",
")",
"{",
"tree",
"var",
"=",
"TREE_VALUE",
"(",
"v",
")",
";",
"if",
"(",
"!",
"var_finalized_p",
"(",
"var",
")",
")",
"{",
"import_export_decl",
"(",
"var",
")",
";",
"rest_of_decl_compilation",
"(",
"var",
",",
"1",
",",
"1",
")",
";",
"}",
"}",
"}"
] | Make sure we have told the back end about all the variables in
VARS. | [
"Make",
"sure",
"we",
"have",
"told",
"the",
"back",
"end",
"about",
"all",
"the",
"variables",
"in",
"VARS",
"."
] | [] | [
{
"param": "vars",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "vars",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | generate_ctor_or_dtor_function | void | static void
generate_ctor_or_dtor_function (bool constructor_p, int priority,
location_t *locus)
{
char function_key;
tree fndecl;
tree body;
size_t i;
input_location = *locus;
/* ??? */
/* Was: locus->line++; */
/* We use `I' to indicate initialization and `D' to indicate
destruction. */
function_key = constructor_p ? 'I' : 'D';
/* We emit the function lazily, to avoid generating empty
global constructors and destructors. */
body = NULL_TREE;
/* For Objective-C++, we may need to initialize metadata found in this module.
This must be done _before_ any other static initializations. */
if (c_dialect_objc () && (priority == DEFAULT_INIT_PRIORITY)
&& constructor_p && objc_static_init_needed_p ())
{
body = start_objects (function_key, priority);
objc_generate_static_init_call (NULL_TREE);
}
/* Call the static storage duration function with appropriate
arguments. */
FOR_EACH_VEC_ELT (tree, ssdf_decls, i, fndecl)
{
/* Calls to pure or const functions will expand to nothing. */
if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
{
tree call;
if (! body)
body = start_objects (function_key, priority);
call = cp_build_function_call_nary (fndecl, tf_warning_or_error,
build_int_cst (NULL_TREE,
constructor_p),
build_int_cst (NULL_TREE,
priority),
NULL_TREE);
finish_expr_stmt (call);
}
}
/* Close out the function. */
if (body)
finish_objects (function_key, priority, body);
} | /* Generate a static constructor (if CONSTRUCTOR_P) or destructor
(otherwise) that will initialize all global objects with static
storage duration having the indicated PRIORITY. */ | Generate a static constructor (if CONSTRUCTOR_P) or destructor
(otherwise) that will initialize all global objects with static
storage duration having the indicated PRIORITY. | [
"Generate",
"a",
"static",
"constructor",
"(",
"if",
"CONSTRUCTOR_P",
")",
"or",
"destructor",
"(",
"otherwise",
")",
"that",
"will",
"initialize",
"all",
"global",
"objects",
"with",
"static",
"storage",
"duration",
"having",
"the",
"indicated",
"PRIORITY",
"."
] | static void
generate_ctor_or_dtor_function (bool constructor_p, int priority,
location_t *locus)
{
char function_key;
tree fndecl;
tree body;
size_t i;
input_location = *locus;
function_key = constructor_p ? 'I' : 'D';
body = NULL_TREE;
if (c_dialect_objc () && (priority == DEFAULT_INIT_PRIORITY)
&& constructor_p && objc_static_init_needed_p ())
{
body = start_objects (function_key, priority);
objc_generate_static_init_call (NULL_TREE);
}
FOR_EACH_VEC_ELT (tree, ssdf_decls, i, fndecl)
{
if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
{
tree call;
if (! body)
body = start_objects (function_key, priority);
call = cp_build_function_call_nary (fndecl, tf_warning_or_error,
build_int_cst (NULL_TREE,
constructor_p),
build_int_cst (NULL_TREE,
priority),
NULL_TREE);
finish_expr_stmt (call);
}
}
if (body)
finish_objects (function_key, priority, body);
} | [
"static",
"void",
"generate_ctor_or_dtor_function",
"(",
"bool",
"constructor_p",
",",
"int",
"priority",
",",
"location_t",
"*",
"locus",
")",
"{",
"char",
"function_key",
";",
"tree",
"fndecl",
";",
"tree",
"body",
";",
"size_t",
"i",
";",
"input_location",
"=",
"*",
"locus",
";",
"function_key",
"=",
"constructor_p",
"?",
"'",
"'",
":",
"'",
"'",
";",
"body",
"=",
"NULL_TREE",
";",
"if",
"(",
"c_dialect_objc",
"(",
")",
"&&",
"(",
"priority",
"==",
"DEFAULT_INIT_PRIORITY",
")",
"&&",
"constructor_p",
"&&",
"objc_static_init_needed_p",
"(",
")",
")",
"{",
"body",
"=",
"start_objects",
"(",
"function_key",
",",
"priority",
")",
";",
"objc_generate_static_init_call",
"(",
"NULL_TREE",
")",
";",
"}",
"FOR_EACH_VEC_ELT",
"(",
"tree",
",",
"ssdf_decls",
",",
"i",
",",
"fndecl",
")",
"",
"{",
"if",
"(",
"!",
"(",
"flags_from_decl_or_type",
"(",
"fndecl",
")",
"&",
"(",
"ECF_CONST",
"|",
"ECF_PURE",
")",
")",
")",
"{",
"tree",
"call",
";",
"if",
"(",
"!",
"body",
")",
"body",
"=",
"start_objects",
"(",
"function_key",
",",
"priority",
")",
";",
"call",
"=",
"cp_build_function_call_nary",
"(",
"fndecl",
",",
"tf_warning_or_error",
",",
"build_int_cst",
"(",
"NULL_TREE",
",",
"constructor_p",
")",
",",
"build_int_cst",
"(",
"NULL_TREE",
",",
"priority",
")",
",",
"NULL_TREE",
")",
";",
"finish_expr_stmt",
"(",
"call",
")",
";",
"}",
"}",
"if",
"(",
"body",
")",
"finish_objects",
"(",
"function_key",
",",
"priority",
",",
"body",
")",
";",
"}"
] | Generate a static constructor (if CONSTRUCTOR_P) or destructor
(otherwise) that will initialize all global objects with static
storage duration having the indicated PRIORITY. | [
"Generate",
"a",
"static",
"constructor",
"(",
"if",
"CONSTRUCTOR_P",
")",
"or",
"destructor",
"(",
"otherwise",
")",
"that",
"will",
"initialize",
"all",
"global",
"objects",
"with",
"static",
"storage",
"duration",
"having",
"the",
"indicated",
"PRIORITY",
"."
] | [
"/* ??? */",
"/* Was: locus->line++; */",
"/* We use `I' to indicate initialization and `D' to indicate\n destruction. */",
"/* We emit the function lazily, to avoid generating empty\n global constructors and destructors. */",
"/* For Objective-C++, we may need to initialize metadata found in this module.\n This must be done _before_ any other static initializations. */",
"/* Call the static storage duration function with appropriate\n arguments. */",
"/* Calls to pure or const functions will expand to nothing. */",
"/* Close out the function. */"
] | [
{
"param": "constructor_p",
"type": "bool"
},
{
"param": "priority",
"type": "int"
},
{
"param": "locus",
"type": "location_t"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "constructor_p",
"type": "bool",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "priority",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "locus",
"type": "location_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | generate_ctor_and_dtor_functions_for_priority | int | static int
generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data)
{
location_t *locus = (location_t *) data;
int priority = (int) n->key;
priority_info pi = (priority_info) n->value;
/* Generate the functions themselves, but only if they are really
needed. */
if (pi->initializations_p)
generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus);
if (pi->destructions_p)
generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus);
/* Keep iterating. */
return 0;
} | /* Generate constructor and destructor functions for the priority
indicated by N. */ | Generate constructor and destructor functions for the priority
indicated by N. | [
"Generate",
"constructor",
"and",
"destructor",
"functions",
"for",
"the",
"priority",
"indicated",
"by",
"N",
"."
] | static int
generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data)
{
location_t *locus = (location_t *) data;
int priority = (int) n->key;
priority_info pi = (priority_info) n->value;
if (pi->initializations_p)
generate_ctor_or_dtor_function (true, priority, locus);
if (pi->destructions_p)
generate_ctor_or_dtor_function (false, priority, locus);
return 0;
} | [
"static",
"int",
"generate_ctor_and_dtor_functions_for_priority",
"(",
"splay_tree_node",
"n",
",",
"void",
"*",
"data",
")",
"{",
"location_t",
"*",
"locus",
"=",
"(",
"location_t",
"*",
")",
"data",
";",
"int",
"priority",
"=",
"(",
"int",
")",
"n",
"->",
"key",
";",
"priority_info",
"pi",
"=",
"(",
"priority_info",
")",
"n",
"->",
"value",
";",
"if",
"(",
"pi",
"->",
"initializations_p",
")",
"generate_ctor_or_dtor_function",
"(",
"true",
",",
"priority",
",",
"locus",
")",
";",
"if",
"(",
"pi",
"->",
"destructions_p",
")",
"generate_ctor_or_dtor_function",
"(",
"false",
",",
"priority",
",",
"locus",
")",
";",
"return",
"0",
";",
"}"
] | Generate constructor and destructor functions for the priority
indicated by N. | [
"Generate",
"constructor",
"and",
"destructor",
"functions",
"for",
"the",
"priority",
"indicated",
"by",
"N",
"."
] | [
"/* Generate the functions themselves, but only if they are really\n needed. */",
"/*constructor_p=*/",
"/*constructor_p=*/",
"/* Keep iterating. */"
] | [
{
"param": "n",
"type": "splay_tree_node"
},
{
"param": "data",
"type": "void"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "n",
"type": "splay_tree_node",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "data",
"type": "void",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | collect_candidates_for_java_method_aliases | null | static struct pointer_set_t *
collect_candidates_for_java_method_aliases (void)
{
struct cgraph_node *node;
struct pointer_set_t *candidates = NULL;
#ifndef HAVE_GAS_HIDDEN
return candidates;
#endif
for (node = cgraph_nodes; node ; node = node->next)
{
tree fndecl = node->decl;
if (DECL_CONTEXT (fndecl)
&& TYPE_P (DECL_CONTEXT (fndecl))
&& TYPE_FOR_JAVA (DECL_CONTEXT (fndecl))
&& TARGET_USE_LOCAL_THUNK_ALIAS_P (fndecl))
{
if (candidates == NULL)
candidates = pointer_set_create ();
pointer_set_insert (candidates, fndecl);
}
}
return candidates;
} | /* Java requires that we be able to reference a local address for a
method, and not be confused by PLT entries. If hidden aliases are
supported, collect and return all the functions for which we should
emit a hidden alias. */ | Java requires that we be able to reference a local address for a
method, and not be confused by PLT entries. If hidden aliases are
supported, collect and return all the functions for which we should
emit a hidden alias. | [
"Java",
"requires",
"that",
"we",
"be",
"able",
"to",
"reference",
"a",
"local",
"address",
"for",
"a",
"method",
"and",
"not",
"be",
"confused",
"by",
"PLT",
"entries",
".",
"If",
"hidden",
"aliases",
"are",
"supported",
"collect",
"and",
"return",
"all",
"the",
"functions",
"for",
"which",
"we",
"should",
"emit",
"a",
"hidden",
"alias",
"."
] | static struct pointer_set_t *
collect_candidates_for_java_method_aliases (void)
{
struct cgraph_node *node;
struct pointer_set_t *candidates = NULL;
#ifndef HAVE_GAS_HIDDEN
return candidates;
#endif
for (node = cgraph_nodes; node ; node = node->next)
{
tree fndecl = node->decl;
if (DECL_CONTEXT (fndecl)
&& TYPE_P (DECL_CONTEXT (fndecl))
&& TYPE_FOR_JAVA (DECL_CONTEXT (fndecl))
&& TARGET_USE_LOCAL_THUNK_ALIAS_P (fndecl))
{
if (candidates == NULL)
candidates = pointer_set_create ();
pointer_set_insert (candidates, fndecl);
}
}
return candidates;
} | [
"static",
"struct",
"pointer_set_t",
"*",
"collect_candidates_for_java_method_aliases",
"(",
"void",
")",
"{",
"struct",
"cgraph_node",
"*",
"node",
";",
"struct",
"pointer_set_t",
"*",
"candidates",
"=",
"NULL",
";",
"#ifndef",
"HAVE_GAS_HIDDEN",
"return",
"candidates",
";",
"#endif",
"for",
"(",
"node",
"=",
"cgraph_nodes",
";",
"node",
";",
"node",
"=",
"node",
"->",
"next",
")",
"{",
"tree",
"fndecl",
"=",
"node",
"->",
"decl",
";",
"if",
"(",
"DECL_CONTEXT",
"(",
"fndecl",
")",
"&&",
"TYPE_P",
"(",
"DECL_CONTEXT",
"(",
"fndecl",
")",
")",
"&&",
"TYPE_FOR_JAVA",
"(",
"DECL_CONTEXT",
"(",
"fndecl",
")",
")",
"&&",
"TARGET_USE_LOCAL_THUNK_ALIAS_P",
"(",
"fndecl",
")",
")",
"{",
"if",
"(",
"candidates",
"==",
"NULL",
")",
"candidates",
"=",
"pointer_set_create",
"(",
")",
";",
"pointer_set_insert",
"(",
"candidates",
",",
"fndecl",
")",
";",
"}",
"}",
"return",
"candidates",
";",
"}"
] | Java requires that we be able to reference a local address for a
method, and not be confused by PLT entries. | [
"Java",
"requires",
"that",
"we",
"be",
"able",
"to",
"reference",
"a",
"local",
"address",
"for",
"a",
"method",
"and",
"not",
"be",
"confused",
"by",
"PLT",
"entries",
"."
] | [] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | build_java_method_aliases | void | static void
build_java_method_aliases (struct pointer_set_t *candidates)
{
struct cgraph_node *node;
#ifndef HAVE_GAS_HIDDEN
return;
#endif
for (node = cgraph_nodes; node ; node = node->next)
{
tree fndecl = node->decl;
if (TREE_ASM_WRITTEN (fndecl)
&& pointer_set_contains (candidates, fndecl))
{
/* Mangle the name in a predictable way; we need to reference
this from a java compiled object file. */
tree oid, nid, alias;
const char *oname;
char *nname;
oid = DECL_ASSEMBLER_NAME (fndecl);
oname = IDENTIFIER_POINTER (oid);
gcc_assert (oname[0] == '_' && oname[1] == 'Z');
nname = ACONCAT (("_ZGA", oname+2, NULL));
nid = get_identifier (nname);
alias = make_alias_for (fndecl, nid);
TREE_PUBLIC (alias) = 1;
DECL_VISIBILITY (alias) = VISIBILITY_HIDDEN;
assemble_alias (alias, oid);
}
}
} | /* Java requires that we be able to reference a local address for a
method, and not be confused by PLT entries. If hidden aliases are
supported, emit one for each java function that we've emitted.
CANDIDATES is the set of FUNCTION_DECLs that were gathered
by collect_candidates_for_java_method_aliases. */ | Java requires that we be able to reference a local address for a
method, and not be confused by PLT entries. If hidden aliases are
supported, emit one for each java function that we've emitted.
CANDIDATES is the set of FUNCTION_DECLs that were gathered
by collect_candidates_for_java_method_aliases. | [
"Java",
"requires",
"that",
"we",
"be",
"able",
"to",
"reference",
"a",
"local",
"address",
"for",
"a",
"method",
"and",
"not",
"be",
"confused",
"by",
"PLT",
"entries",
".",
"If",
"hidden",
"aliases",
"are",
"supported",
"emit",
"one",
"for",
"each",
"java",
"function",
"that",
"we",
"'",
"ve",
"emitted",
".",
"CANDIDATES",
"is",
"the",
"set",
"of",
"FUNCTION_DECLs",
"that",
"were",
"gathered",
"by",
"collect_candidates_for_java_method_aliases",
"."
] | static void
build_java_method_aliases (struct pointer_set_t *candidates)
{
struct cgraph_node *node;
#ifndef HAVE_GAS_HIDDEN
return;
#endif
for (node = cgraph_nodes; node ; node = node->next)
{
tree fndecl = node->decl;
if (TREE_ASM_WRITTEN (fndecl)
&& pointer_set_contains (candidates, fndecl))
{
tree oid, nid, alias;
const char *oname;
char *nname;
oid = DECL_ASSEMBLER_NAME (fndecl);
oname = IDENTIFIER_POINTER (oid);
gcc_assert (oname[0] == '_' && oname[1] == 'Z');
nname = ACONCAT (("_ZGA", oname+2, NULL));
nid = get_identifier (nname);
alias = make_alias_for (fndecl, nid);
TREE_PUBLIC (alias) = 1;
DECL_VISIBILITY (alias) = VISIBILITY_HIDDEN;
assemble_alias (alias, oid);
}
}
} | [
"static",
"void",
"build_java_method_aliases",
"(",
"struct",
"pointer_set_t",
"*",
"candidates",
")",
"{",
"struct",
"cgraph_node",
"*",
"node",
";",
"#ifndef",
"HAVE_GAS_HIDDEN",
"return",
";",
"#endif",
"for",
"(",
"node",
"=",
"cgraph_nodes",
";",
"node",
";",
"node",
"=",
"node",
"->",
"next",
")",
"{",
"tree",
"fndecl",
"=",
"node",
"->",
"decl",
";",
"if",
"(",
"TREE_ASM_WRITTEN",
"(",
"fndecl",
")",
"&&",
"pointer_set_contains",
"(",
"candidates",
",",
"fndecl",
")",
")",
"{",
"tree",
"oid",
",",
"nid",
",",
"alias",
";",
"const",
"char",
"*",
"oname",
";",
"char",
"*",
"nname",
";",
"oid",
"=",
"DECL_ASSEMBLER_NAME",
"(",
"fndecl",
")",
";",
"oname",
"=",
"IDENTIFIER_POINTER",
"(",
"oid",
")",
";",
"gcc_assert",
"(",
"oname",
"[",
"0",
"]",
"==",
"'",
"'",
"&&",
"oname",
"[",
"1",
"]",
"==",
"'",
"'",
")",
";",
"nname",
"=",
"ACONCAT",
"(",
"(",
"\"",
"\"",
",",
"oname",
"+",
"2",
",",
"NULL",
")",
")",
";",
"nid",
"=",
"get_identifier",
"(",
"nname",
")",
";",
"alias",
"=",
"make_alias_for",
"(",
"fndecl",
",",
"nid",
")",
";",
"TREE_PUBLIC",
"(",
"alias",
")",
"=",
"1",
";",
"DECL_VISIBILITY",
"(",
"alias",
")",
"=",
"VISIBILITY_HIDDEN",
";",
"assemble_alias",
"(",
"alias",
",",
"oid",
")",
";",
"}",
"}",
"}"
] | Java requires that we be able to reference a local address for a
method, and not be confused by PLT entries. | [
"Java",
"requires",
"that",
"we",
"be",
"able",
"to",
"reference",
"a",
"local",
"address",
"for",
"a",
"method",
"and",
"not",
"be",
"confused",
"by",
"PLT",
"entries",
"."
] | [
"/* Mangle the name in a predictable way; we need to reference\n\t this from a java compiled object file. */"
] | [
{
"param": "candidates",
"type": "struct pointer_set_t"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "candidates",
"type": "struct pointer_set_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | cpp_check | int | static int
cpp_check (tree t, cpp_operation op)
{
switch (op)
{
case IS_ABSTRACT:
return DECL_PURE_VIRTUAL_P (t);
case IS_CONSTRUCTOR:
return DECL_CONSTRUCTOR_P (t);
case IS_DESTRUCTOR:
return DECL_DESTRUCTOR_P (t);
case IS_COPY_CONSTRUCTOR:
return DECL_COPY_CONSTRUCTOR_P (t);
case IS_TEMPLATE:
return TREE_CODE (t) == TEMPLATE_DECL;
default:
return 0;
}
} | /* Return C++ property of T, based on given operation OP. */ | Return C++ property of T, based on given operation OP. | [
"Return",
"C",
"++",
"property",
"of",
"T",
"based",
"on",
"given",
"operation",
"OP",
"."
] | static int
cpp_check (tree t, cpp_operation op)
{
switch (op)
{
case IS_ABSTRACT:
return DECL_PURE_VIRTUAL_P (t);
case IS_CONSTRUCTOR:
return DECL_CONSTRUCTOR_P (t);
case IS_DESTRUCTOR:
return DECL_DESTRUCTOR_P (t);
case IS_COPY_CONSTRUCTOR:
return DECL_COPY_CONSTRUCTOR_P (t);
case IS_TEMPLATE:
return TREE_CODE (t) == TEMPLATE_DECL;
default:
return 0;
}
} | [
"static",
"int",
"cpp_check",
"(",
"tree",
"t",
",",
"cpp_operation",
"op",
")",
"{",
"switch",
"(",
"op",
")",
"{",
"case",
"IS_ABSTRACT",
":",
"return",
"DECL_PURE_VIRTUAL_P",
"(",
"t",
")",
";",
"case",
"IS_CONSTRUCTOR",
":",
"return",
"DECL_CONSTRUCTOR_P",
"(",
"t",
")",
";",
"case",
"IS_DESTRUCTOR",
":",
"return",
"DECL_DESTRUCTOR_P",
"(",
"t",
")",
";",
"case",
"IS_COPY_CONSTRUCTOR",
":",
"return",
"DECL_COPY_CONSTRUCTOR_P",
"(",
"t",
")",
";",
"case",
"IS_TEMPLATE",
":",
"return",
"TREE_CODE",
"(",
"t",
")",
"==",
"TEMPLATE_DECL",
";",
"default",
":",
"return",
"0",
";",
"}",
"}"
] | Return C++ property of T, based on given operation OP. | [
"Return",
"C",
"++",
"property",
"of",
"T",
"based",
"on",
"given",
"operation",
"OP",
"."
] | [] | [
{
"param": "t",
"type": "tree"
},
{
"param": "op",
"type": "cpp_operation"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "t",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "op",
"type": "cpp_operation",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | collect_source_refs | void | static void
collect_source_refs (tree namespc)
{
tree t;
if (!namespc)
return;
/* Iterate over names in this name space. */
for (t = NAMESPACE_LEVEL (namespc)->names; t; t = TREE_CHAIN (t))
if (!DECL_IS_BUILTIN (t) )
collect_source_ref (DECL_SOURCE_FILE (t));
/* Dump siblings, if any */
collect_source_refs (TREE_CHAIN (namespc));
/* Dump children, if any */
collect_source_refs (NAMESPACE_LEVEL (namespc)->namespaces);
} | /* Collect source file references recursively, starting from NAMESPC. */ | Collect source file references recursively, starting from NAMESPC. | [
"Collect",
"source",
"file",
"references",
"recursively",
"starting",
"from",
"NAMESPC",
"."
] | static void
collect_source_refs (tree namespc)
{
tree t;
if (!namespc)
return;
for (t = NAMESPACE_LEVEL (namespc)->names; t; t = TREE_CHAIN (t))
if (!DECL_IS_BUILTIN (t) )
collect_source_ref (DECL_SOURCE_FILE (t));
collect_source_refs (TREE_CHAIN (namespc));
collect_source_refs (NAMESPACE_LEVEL (namespc)->namespaces);
} | [
"static",
"void",
"collect_source_refs",
"(",
"tree",
"namespc",
")",
"{",
"tree",
"t",
";",
"if",
"(",
"!",
"namespc",
")",
"return",
";",
"for",
"(",
"t",
"=",
"NAMESPACE_LEVEL",
"(",
"namespc",
")",
"->",
"names",
";",
"t",
";",
"t",
"=",
"TREE_CHAIN",
"(",
"t",
")",
")",
"if",
"(",
"!",
"DECL_IS_BUILTIN",
"(",
"t",
")",
")",
"collect_source_ref",
"(",
"DECL_SOURCE_FILE",
"(",
"t",
")",
")",
";",
"collect_source_refs",
"(",
"TREE_CHAIN",
"(",
"namespc",
")",
")",
";",
"collect_source_refs",
"(",
"NAMESPACE_LEVEL",
"(",
"namespc",
")",
"->",
"namespaces",
")",
";",
"}"
] | Collect source file references recursively, starting from NAMESPC. | [
"Collect",
"source",
"file",
"references",
"recursively",
"starting",
"from",
"NAMESPC",
"."
] | [
"/* Iterate over names in this name space. */",
"/* Dump siblings, if any */",
"/* Dump children, if any */"
] | [
{
"param": "namespc",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "namespc",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | collect_ada_namespace | void | static void
collect_ada_namespace (tree namespc, const char *source_file)
{
if (!namespc)
return;
/* Collect decls from this namespace */
collect_ada_nodes (NAMESPACE_LEVEL (namespc)->names, source_file);
/* Collect siblings, if any */
collect_ada_namespace (TREE_CHAIN (namespc), source_file);
/* Collect children, if any */
collect_ada_namespace (NAMESPACE_LEVEL (namespc)->namespaces, source_file);
} | /* Collect decls relevant to SOURCE_FILE from all namespaces recursively,
starting from NAMESPC. */ | Collect decls relevant to SOURCE_FILE from all namespaces recursively,
starting from NAMESPC. | [
"Collect",
"decls",
"relevant",
"to",
"SOURCE_FILE",
"from",
"all",
"namespaces",
"recursively",
"starting",
"from",
"NAMESPC",
"."
] | static void
collect_ada_namespace (tree namespc, const char *source_file)
{
if (!namespc)
return;
collect_ada_nodes (NAMESPACE_LEVEL (namespc)->names, source_file);
collect_ada_namespace (TREE_CHAIN (namespc), source_file);
collect_ada_namespace (NAMESPACE_LEVEL (namespc)->namespaces, source_file);
} | [
"static",
"void",
"collect_ada_namespace",
"(",
"tree",
"namespc",
",",
"const",
"char",
"*",
"source_file",
")",
"{",
"if",
"(",
"!",
"namespc",
")",
"return",
";",
"collect_ada_nodes",
"(",
"NAMESPACE_LEVEL",
"(",
"namespc",
")",
"->",
"names",
",",
"source_file",
")",
";",
"collect_ada_namespace",
"(",
"TREE_CHAIN",
"(",
"namespc",
")",
",",
"source_file",
")",
";",
"collect_ada_namespace",
"(",
"NAMESPACE_LEVEL",
"(",
"namespc",
")",
"->",
"namespaces",
",",
"source_file",
")",
";",
"}"
] | Collect decls relevant to SOURCE_FILE from all namespaces recursively,
starting from NAMESPC. | [
"Collect",
"decls",
"relevant",
"to",
"SOURCE_FILE",
"from",
"all",
"namespaces",
"recursively",
"starting",
"from",
"NAMESPC",
"."
] | [
"/* Collect decls from this namespace */",
"/* Collect siblings, if any */",
"/* Collect children, if any */"
] | [
{
"param": "namespc",
"type": "tree"
},
{
"param": "source_file",
"type": "char"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "namespc",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "source_file",
"type": "char",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | decl_defined_p | bool | static bool
decl_defined_p (tree decl)
{
if (TREE_CODE (decl) == FUNCTION_DECL)
return (DECL_INITIAL (decl) != NULL_TREE);
else
{
gcc_assert (TREE_CODE (decl) == VAR_DECL);
return !DECL_EXTERNAL (decl);
}
} | /* Returns true iff there is a definition available for variable or
function DECL. */ | Returns true iff there is a definition available for variable or
function DECL. | [
"Returns",
"true",
"iff",
"there",
"is",
"a",
"definition",
"available",
"for",
"variable",
"or",
"function",
"DECL",
"."
] | static bool
decl_defined_p (tree decl)
{
if (TREE_CODE (decl) == FUNCTION_DECL)
return (DECL_INITIAL (decl) != NULL_TREE);
else
{
gcc_assert (TREE_CODE (decl) == VAR_DECL);
return !DECL_EXTERNAL (decl);
}
} | [
"static",
"bool",
"decl_defined_p",
"(",
"tree",
"decl",
")",
"{",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
")",
"return",
"(",
"DECL_INITIAL",
"(",
"decl",
")",
"!=",
"NULL_TREE",
")",
";",
"else",
"{",
"gcc_assert",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"VAR_DECL",
")",
";",
"return",
"!",
"DECL_EXTERNAL",
"(",
"decl",
")",
";",
"}",
"}"
] | Returns true iff there is a definition available for variable or
function DECL. | [
"Returns",
"true",
"iff",
"there",
"is",
"a",
"definition",
"available",
"for",
"variable",
"or",
"function",
"DECL",
"."
] | [] | [
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | decl_constant_var_p | bool | bool
decl_constant_var_p (tree decl)
{
if (!decl_maybe_constant_var_p (decl))
return false;
/* We don't know if a template static data member is initialized with
a constant expression until we instantiate its initializer. Even
in the case of a constexpr variable, we can't treat it as a
constant until its initializer is complete in case it's used in
its own initializer. */
mark_used (decl);
return DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl);
} | /* Nonzero for a VAR_DECL whose value can be used in a constant expression.
[expr.const]
An integral constant-expression can only involve ... const
variables of integral or enumeration types initialized with
constant expressions ...
C++0x also allows constexpr variables and temporaries initialized
with constant expressions. We handle the former here, but the latter
are just folded away in cxx_eval_constant_expression.
The standard does not require that the expression be non-volatile.
G++ implements the proposed correction in DR 457. */ | Nonzero for a VAR_DECL whose value can be used in a constant expression.
An integral constant-expression can only involve ... const
variables of integral or enumeration types initialized with
constant expressions
C++0x also allows constexpr variables and temporaries initialized
with constant expressions. We handle the former here, but the latter
are just folded away in cxx_eval_constant_expression.
The standard does not require that the expression be non-volatile.
G++ implements the proposed correction in DR 457. | [
"Nonzero",
"for",
"a",
"VAR_DECL",
"whose",
"value",
"can",
"be",
"used",
"in",
"a",
"constant",
"expression",
".",
"An",
"integral",
"constant",
"-",
"expression",
"can",
"only",
"involve",
"...",
"const",
"variables",
"of",
"integral",
"or",
"enumeration",
"types",
"initialized",
"with",
"constant",
"expressions",
"C",
"++",
"0x",
"also",
"allows",
"constexpr",
"variables",
"and",
"temporaries",
"initialized",
"with",
"constant",
"expressions",
".",
"We",
"handle",
"the",
"former",
"here",
"but",
"the",
"latter",
"are",
"just",
"folded",
"away",
"in",
"cxx_eval_constant_expression",
".",
"The",
"standard",
"does",
"not",
"require",
"that",
"the",
"expression",
"be",
"non",
"-",
"volatile",
".",
"G",
"++",
"implements",
"the",
"proposed",
"correction",
"in",
"DR",
"457",
"."
] | bool
decl_constant_var_p (tree decl)
{
if (!decl_maybe_constant_var_p (decl))
return false;
mark_used (decl);
return DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl);
} | [
"bool",
"decl_constant_var_p",
"(",
"tree",
"decl",
")",
"{",
"if",
"(",
"!",
"decl_maybe_constant_var_p",
"(",
"decl",
")",
")",
"return",
"false",
";",
"mark_used",
"(",
"decl",
")",
";",
"return",
"DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P",
"(",
"decl",
")",
";",
"}"
] | Nonzero for a VAR_DECL whose value can be used in a constant expression. | [
"Nonzero",
"for",
"a",
"VAR_DECL",
"whose",
"value",
"can",
"be",
"used",
"in",
"a",
"constant",
"expression",
"."
] | [
"/* We don't know if a template static data member is initialized with\n a constant expression until we instantiate its initializer. Even\n in the case of a constexpr variable, we can't treat it as a\n constant until its initializer is complete in case it's used in\n its own initializer. */"
] | [
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | decl_maybe_constant_var_p | bool | bool
decl_maybe_constant_var_p (tree decl)
{
tree type = TREE_TYPE (decl);
if (TREE_CODE (decl) != VAR_DECL)
return false;
if (DECL_DECLARED_CONSTEXPR_P (decl))
return true;
return (CP_TYPE_CONST_NON_VOLATILE_P (type)
&& INTEGRAL_OR_ENUMERATION_TYPE_P (type));
} | /* Returns true if DECL could be a symbolic constant variable, depending on
its initializer. */ | Returns true if DECL could be a symbolic constant variable, depending on
its initializer. | [
"Returns",
"true",
"if",
"DECL",
"could",
"be",
"a",
"symbolic",
"constant",
"variable",
"depending",
"on",
"its",
"initializer",
"."
] | bool
decl_maybe_constant_var_p (tree decl)
{
tree type = TREE_TYPE (decl);
if (TREE_CODE (decl) != VAR_DECL)
return false;
if (DECL_DECLARED_CONSTEXPR_P (decl))
return true;
return (CP_TYPE_CONST_NON_VOLATILE_P (type)
&& INTEGRAL_OR_ENUMERATION_TYPE_P (type));
} | [
"bool",
"decl_maybe_constant_var_p",
"(",
"tree",
"decl",
")",
"{",
"tree",
"type",
"=",
"TREE_TYPE",
"(",
"decl",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"!=",
"VAR_DECL",
")",
"return",
"false",
";",
"if",
"(",
"DECL_DECLARED_CONSTEXPR_P",
"(",
"decl",
")",
")",
"return",
"true",
";",
"return",
"(",
"CP_TYPE_CONST_NON_VOLATILE_P",
"(",
"type",
")",
"&&",
"INTEGRAL_OR_ENUMERATION_TYPE_P",
"(",
"type",
")",
")",
";",
"}"
] | Returns true if DECL could be a symbolic constant variable, depending on
its initializer. | [
"Returns",
"true",
"if",
"DECL",
"could",
"be",
"a",
"symbolic",
"constant",
"variable",
"depending",
"on",
"its",
"initializer",
"."
] | [] | [
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | no_linkage_error | void | static void
no_linkage_error (tree decl)
{
tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
if (TYPE_ANONYMOUS_P (t))
{
permerror (0, "%q+#D, declared using anonymous type, "
"is used but never defined", decl);
if (is_typedef_decl (TYPE_NAME (t)))
permerror (0, "%q+#D does not refer to the unqualified type, "
"so it is not used for linkage", TYPE_NAME (t));
}
else
permerror (0, "%q+#D, declared using local type %qT, "
"is used but never defined", decl, t);
} | /* Complain that DECL uses a type with no linkage but is never defined. */ | Complain that DECL uses a type with no linkage but is never defined. | [
"Complain",
"that",
"DECL",
"uses",
"a",
"type",
"with",
"no",
"linkage",
"but",
"is",
"never",
"defined",
"."
] | static void
no_linkage_error (tree decl)
{
tree t = no_linkage_check (TREE_TYPE (decl), false);
if (TYPE_ANONYMOUS_P (t))
{
permerror (0, "%q+#D, declared using anonymous type, "
"is used but never defined", decl);
if (is_typedef_decl (TYPE_NAME (t)))
permerror (0, "%q+#D does not refer to the unqualified type, "
"so it is not used for linkage", TYPE_NAME (t));
}
else
permerror (0, "%q+#D, declared using local type %qT, "
"is used but never defined", decl, t);
} | [
"static",
"void",
"no_linkage_error",
"(",
"tree",
"decl",
")",
"{",
"tree",
"t",
"=",
"no_linkage_check",
"(",
"TREE_TYPE",
"(",
"decl",
")",
",",
"false",
")",
";",
"if",
"(",
"TYPE_ANONYMOUS_P",
"(",
"t",
")",
")",
"{",
"permerror",
"(",
"0",
",",
"\"",
"\"",
"\"",
"\"",
",",
"decl",
")",
";",
"if",
"(",
"is_typedef_decl",
"(",
"TYPE_NAME",
"(",
"t",
")",
")",
")",
"permerror",
"(",
"0",
",",
"\"",
"\"",
"\"",
"\"",
",",
"TYPE_NAME",
"(",
"t",
")",
")",
";",
"}",
"else",
"permerror",
"(",
"0",
",",
"\"",
"\"",
"\"",
"\"",
",",
"decl",
",",
"t",
")",
";",
"}"
] | Complain that DECL uses a type with no linkage but is never defined. | [
"Complain",
"that",
"DECL",
"uses",
"a",
"type",
"with",
"no",
"linkage",
"but",
"is",
"never",
"defined",
"."
] | [
"/*relaxed_p=*/"
] | [
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | collect_all_refs | void | static void
collect_all_refs (const char *source_file)
{
collect_ada_namespace (global_namespace, source_file);
} | /* Collect declarations from all namespaces relevant to SOURCE_FILE. */ | Collect declarations from all namespaces relevant to SOURCE_FILE. | [
"Collect",
"declarations",
"from",
"all",
"namespaces",
"relevant",
"to",
"SOURCE_FILE",
"."
] | static void
collect_all_refs (const char *source_file)
{
collect_ada_namespace (global_namespace, source_file);
} | [
"static",
"void",
"collect_all_refs",
"(",
"const",
"char",
"*",
"source_file",
")",
"{",
"collect_ada_namespace",
"(",
"global_namespace",
",",
"source_file",
")",
";",
"}"
] | Collect declarations from all namespaces relevant to SOURCE_FILE. | [
"Collect",
"declarations",
"from",
"all",
"namespaces",
"relevant",
"to",
"SOURCE_FILE",
"."
] | [] | [
{
"param": "source_file",
"type": "char"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "source_file",
"type": "char",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | possibly_inlined_p | bool | bool
possibly_inlined_p (tree decl)
{
gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
if (DECL_UNINLINABLE (decl))
return false;
if (!optimize || pragma_java_exceptions)
return DECL_DECLARED_INLINE_P (decl);
/* When optimizing, we might inline everything when flatten
attribute or heuristics inlining for size or autoinlining
is used. */
return true;
} | /* Return true if function DECL can be inlined. This is used to force
instantiation of methods that might be interesting for inlining. */ | Return true if function DECL can be inlined. This is used to force
instantiation of methods that might be interesting for inlining. | [
"Return",
"true",
"if",
"function",
"DECL",
"can",
"be",
"inlined",
".",
"This",
"is",
"used",
"to",
"force",
"instantiation",
"of",
"methods",
"that",
"might",
"be",
"interesting",
"for",
"inlining",
"."
] | bool
possibly_inlined_p (tree decl)
{
gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
if (DECL_UNINLINABLE (decl))
return false;
if (!optimize || pragma_java_exceptions)
return DECL_DECLARED_INLINE_P (decl);
return true;
} | [
"bool",
"possibly_inlined_p",
"(",
"tree",
"decl",
")",
"{",
"gcc_assert",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
")",
";",
"if",
"(",
"DECL_UNINLINABLE",
"(",
"decl",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"optimize",
"||",
"pragma_java_exceptions",
")",
"return",
"DECL_DECLARED_INLINE_P",
"(",
"decl",
")",
";",
"return",
"true",
";",
"}"
] | Return true if function DECL can be inlined. | [
"Return",
"true",
"if",
"function",
"DECL",
"can",
"be",
"inlined",
"."
] | [
"/* When optimizing, we might inline everything when flatten\n attribute or heuristics inlining for size or autoinlining\n is used. */"
] | [
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f23062b59ad81c4fffbce94f5f2f8dd6690dd5c8 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/cp/decl2.c | [
"BSD-3-Clause"
] | C | mark_used | bool | bool
mark_used (tree decl)
{
/* If DECL is a BASELINK for a single function, then treat it just
like the DECL for the function. Otherwise, if the BASELINK is
for an overloaded function, we don't know which function was
actually used until after overload resolution. */
if (BASELINK_P (decl))
{
decl = BASELINK_FUNCTIONS (decl);
if (really_overloaded_fn (decl))
return true;
decl = OVL_CURRENT (decl);
}
/* Set TREE_USED for the benefit of -Wunused. */
TREE_USED (decl) = 1;
if (DECL_CLONED_FUNCTION_P (decl))
TREE_USED (DECL_CLONED_FUNCTION (decl)) = 1;
if (TREE_CODE (decl) == FUNCTION_DECL
&& DECL_DELETED_FN (decl))
{
if (DECL_ARTIFICIAL (decl))
{
if (DECL_OVERLOADED_OPERATOR_P (decl) == TYPE_EXPR
&& LAMBDA_TYPE_P (DECL_CONTEXT (decl)))
{
/* We mark a lambda conversion op as deleted if we can't
generate it properly; see maybe_add_lambda_conv_op. */
sorry ("converting lambda which uses %<...%> to "
"function pointer");
return false;
}
}
error ("use of deleted function %qD", decl);
if (!maybe_explain_implicit_delete (decl))
error_at (DECL_SOURCE_LOCATION (decl), "declared here");
return false;
}
/* We can only check DECL_ODR_USED on variables or functions with
DECL_LANG_SPECIFIC set, and these are also the only decls that we
might need special handling for. */
if ((TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
|| DECL_LANG_SPECIFIC (decl) == NULL
|| DECL_THUNK_P (decl))
return true;
/* We only want to do this processing once. We don't need to keep trying
to instantiate inline templates, because unit-at-a-time will make sure
we get them compiled before functions that want to inline them. */
if (DECL_ODR_USED (decl))
return true;
/* If within finish_function, defer the rest until that function
finishes, otherwise it might recurse. */
if (defer_mark_used_calls)
{
VEC_safe_push (tree, gc, deferred_mark_used_calls, decl);
return true;
}
if (TREE_CODE (decl) == FUNCTION_DECL)
maybe_instantiate_noexcept (decl);
/* Normally, we can wait until instantiation-time to synthesize DECL.
However, if DECL is a static data member initialized with a constant
or a constexpr function, we need it right now because a reference to
such a data member or a call to such function is not value-dependent. */
if ((decl_maybe_constant_var_p (decl)
|| (TREE_CODE (decl) == FUNCTION_DECL
&& DECL_DECLARED_CONSTEXPR_P (decl)))
&& DECL_LANG_SPECIFIC (decl)
&& DECL_TEMPLATE_INFO (decl)
&& !uses_template_parms (DECL_TI_ARGS (decl)))
{
/* Instantiating a function will result in garbage collection. We
must treat this situation as if we were within the body of a
function so as to avoid collecting live data only referenced from
the stack (such as overload resolution candidates). */
++function_depth;
instantiate_decl (decl, /*defer_ok=*/false,
/*expl_inst_class_mem_p=*/false);
--function_depth;
}
/* If we don't need a value, then we don't need to synthesize DECL. */
if (cp_unevaluated_operand != 0)
return true;
if (processing_template_decl)
return true;
/* Check this too in case we're within fold_non_dependent_expr. */
if (DECL_TEMPLATE_INFO (decl)
&& uses_template_parms (DECL_TI_ARGS (decl)))
return true;
DECL_ODR_USED (decl) = 1;
if (DECL_CLONED_FUNCTION_P (decl))
DECL_ODR_USED (DECL_CLONED_FUNCTION (decl)) = 1;
/* DR 757: A type without linkage shall not be used as the type of a
variable or function with linkage, unless
o the variable or function has extern "C" linkage (7.5 [dcl.link]), or
o the variable or function is not used (3.2 [basic.def.odr]) or is
defined in the same translation unit. */
if (cxx_dialect > cxx98
&& decl_linkage (decl) != lk_none
&& !DECL_EXTERN_C_P (decl)
&& !DECL_ARTIFICIAL (decl)
&& !decl_defined_p (decl)
&& no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false))
{
if (is_local_extern (decl))
/* There's no way to define a local extern, and adding it to
the vector interferes with GC, so give an error now. */
no_linkage_error (decl);
else
VEC_safe_push (tree, gc, no_linkage_decls, decl);
}
if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)
&& !DECL_INITIAL (decl) && !DECL_ARTIFICIAL (decl))
/* Remember it, so we can check it was defined. */
note_vague_linkage_fn (decl);
/* Is it a synthesized method that needs to be synthesized? */
if (TREE_CODE (decl) == FUNCTION_DECL
&& DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
&& DECL_DEFAULTED_FN (decl)
/* A function defaulted outside the class is synthesized either by
cp_finish_decl or instantiate_decl. */
&& !DECL_DEFAULTED_OUTSIDE_CLASS_P (decl)
&& ! DECL_INITIAL (decl))
{
/* Defer virtual destructors so that thunks get the right
linkage. */
if (DECL_VIRTUAL_P (decl) && !at_eof)
{
note_vague_linkage_fn (decl);
return true;
}
/* Remember the current location for a function we will end up
synthesizing. Then we can inform the user where it was
required in the case of error. */
DECL_SOURCE_LOCATION (decl) = input_location;
/* Synthesizing an implicitly defined member function will result in
garbage collection. We must treat this situation as if we were
within the body of a function so as to avoid collecting live data
on the stack (such as overload resolution candidates).
We could just let cp_write_global_declarations handle synthesizing
this function by adding it to deferred_fns, but doing
it at the use site produces better error messages. */
++function_depth;
synthesize_method (decl);
--function_depth;
/* If this is a synthesized method we don't need to
do the instantiation test below. */
}
else if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
&& DECL_TEMPLATE_INFO (decl)
&& (!DECL_EXPLICIT_INSTANTIATION (decl)
|| always_instantiate_p (decl)))
/* If this is a function or variable that is an instance of some
template, we now know that we will need to actually do the
instantiation. We check that DECL is not an explicit
instantiation because that is not checked in instantiate_decl.
We put off instantiating functions in order to improve compile
times. Maintaining a stack of active functions is expensive,
and the inliner knows to instantiate any functions it might
need. Therefore, we always try to defer instantiation. */
{
++function_depth;
instantiate_decl (decl, /*defer_ok=*/true,
/*expl_inst_class_mem_p=*/false);
--function_depth;
}
return true;
} | /* Mark DECL (either a _DECL or a BASELINK) as "used" in the program.
If DECL is a specialization or implicitly declared class member,
generate the actual definition. Return false if something goes
wrong, true otherwise. */ | Mark DECL (either a _DECL or a BASELINK) as "used" in the program.
If DECL is a specialization or implicitly declared class member,
generate the actual definition. Return false if something goes
wrong, true otherwise. | [
"Mark",
"DECL",
"(",
"either",
"a",
"_DECL",
"or",
"a",
"BASELINK",
")",
"as",
"\"",
"used",
"\"",
"in",
"the",
"program",
".",
"If",
"DECL",
"is",
"a",
"specialization",
"or",
"implicitly",
"declared",
"class",
"member",
"generate",
"the",
"actual",
"definition",
".",
"Return",
"false",
"if",
"something",
"goes",
"wrong",
"true",
"otherwise",
"."
] | bool
mark_used (tree decl)
{
if (BASELINK_P (decl))
{
decl = BASELINK_FUNCTIONS (decl);
if (really_overloaded_fn (decl))
return true;
decl = OVL_CURRENT (decl);
}
TREE_USED (decl) = 1;
if (DECL_CLONED_FUNCTION_P (decl))
TREE_USED (DECL_CLONED_FUNCTION (decl)) = 1;
if (TREE_CODE (decl) == FUNCTION_DECL
&& DECL_DELETED_FN (decl))
{
if (DECL_ARTIFICIAL (decl))
{
if (DECL_OVERLOADED_OPERATOR_P (decl) == TYPE_EXPR
&& LAMBDA_TYPE_P (DECL_CONTEXT (decl)))
{
sorry ("converting lambda which uses %<...%> to "
"function pointer");
return false;
}
}
error ("use of deleted function %qD", decl);
if (!maybe_explain_implicit_delete (decl))
error_at (DECL_SOURCE_LOCATION (decl), "declared here");
return false;
}
if ((TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
|| DECL_LANG_SPECIFIC (decl) == NULL
|| DECL_THUNK_P (decl))
return true;
if (DECL_ODR_USED (decl))
return true;
if (defer_mark_used_calls)
{
VEC_safe_push (tree, gc, deferred_mark_used_calls, decl);
return true;
}
if (TREE_CODE (decl) == FUNCTION_DECL)
maybe_instantiate_noexcept (decl);
if ((decl_maybe_constant_var_p (decl)
|| (TREE_CODE (decl) == FUNCTION_DECL
&& DECL_DECLARED_CONSTEXPR_P (decl)))
&& DECL_LANG_SPECIFIC (decl)
&& DECL_TEMPLATE_INFO (decl)
&& !uses_template_parms (DECL_TI_ARGS (decl)))
{
++function_depth;
instantiate_decl (decl, false,
false);
--function_depth;
}
if (cp_unevaluated_operand != 0)
return true;
if (processing_template_decl)
return true;
if (DECL_TEMPLATE_INFO (decl)
&& uses_template_parms (DECL_TI_ARGS (decl)))
return true;
DECL_ODR_USED (decl) = 1;
if (DECL_CLONED_FUNCTION_P (decl))
DECL_ODR_USED (DECL_CLONED_FUNCTION (decl)) = 1;
if (cxx_dialect > cxx98
&& decl_linkage (decl) != lk_none
&& !DECL_EXTERN_C_P (decl)
&& !DECL_ARTIFICIAL (decl)
&& !decl_defined_p (decl)
&& no_linkage_check (TREE_TYPE (decl), false))
{
if (is_local_extern (decl))
no_linkage_error (decl);
else
VEC_safe_push (tree, gc, no_linkage_decls, decl);
}
if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)
&& !DECL_INITIAL (decl) && !DECL_ARTIFICIAL (decl))
note_vague_linkage_fn (decl);
if (TREE_CODE (decl) == FUNCTION_DECL
&& DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
&& DECL_DEFAULTED_FN (decl)
&& !DECL_DEFAULTED_OUTSIDE_CLASS_P (decl)
&& ! DECL_INITIAL (decl))
{
if (DECL_VIRTUAL_P (decl) && !at_eof)
{
note_vague_linkage_fn (decl);
return true;
}
DECL_SOURCE_LOCATION (decl) = input_location;
++function_depth;
synthesize_method (decl);
--function_depth;
}
else if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
&& DECL_TEMPLATE_INFO (decl)
&& (!DECL_EXPLICIT_INSTANTIATION (decl)
|| always_instantiate_p (decl)))
{
++function_depth;
instantiate_decl (decl, true,
false);
--function_depth;
}
return true;
} | [
"bool",
"mark_used",
"(",
"tree",
"decl",
")",
"{",
"if",
"(",
"BASELINK_P",
"(",
"decl",
")",
")",
"{",
"decl",
"=",
"BASELINK_FUNCTIONS",
"(",
"decl",
")",
";",
"if",
"(",
"really_overloaded_fn",
"(",
"decl",
")",
")",
"return",
"true",
";",
"decl",
"=",
"OVL_CURRENT",
"(",
"decl",
")",
";",
"}",
"TREE_USED",
"(",
"decl",
")",
"=",
"1",
";",
"if",
"(",
"DECL_CLONED_FUNCTION_P",
"(",
"decl",
")",
")",
"TREE_USED",
"(",
"DECL_CLONED_FUNCTION",
"(",
"decl",
")",
")",
"=",
"1",
";",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
"&&",
"DECL_DELETED_FN",
"(",
"decl",
")",
")",
"{",
"if",
"(",
"DECL_ARTIFICIAL",
"(",
"decl",
")",
")",
"{",
"if",
"(",
"DECL_OVERLOADED_OPERATOR_P",
"(",
"decl",
")",
"==",
"TYPE_EXPR",
"&&",
"LAMBDA_TYPE_P",
"(",
"DECL_CONTEXT",
"(",
"decl",
")",
")",
")",
"{",
"sorry",
"(",
"\"",
"\"",
"\"",
"\"",
")",
";",
"return",
"false",
";",
"}",
"}",
"error",
"(",
"\"",
"\"",
",",
"decl",
")",
";",
"if",
"(",
"!",
"maybe_explain_implicit_delete",
"(",
"decl",
")",
")",
"error_at",
"(",
"DECL_SOURCE_LOCATION",
"(",
"decl",
")",
",",
"\"",
"\"",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"(",
"TREE_CODE",
"(",
"decl",
")",
"!=",
"VAR_DECL",
"&&",
"TREE_CODE",
"(",
"decl",
")",
"!=",
"FUNCTION_DECL",
")",
"||",
"DECL_LANG_SPECIFIC",
"(",
"decl",
")",
"==",
"NULL",
"||",
"DECL_THUNK_P",
"(",
"decl",
")",
")",
"return",
"true",
";",
"if",
"(",
"DECL_ODR_USED",
"(",
"decl",
")",
")",
"return",
"true",
";",
"if",
"(",
"defer_mark_used_calls",
")",
"{",
"VEC_safe_push",
"(",
"tree",
",",
"gc",
",",
"deferred_mark_used_calls",
",",
"decl",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
")",
"maybe_instantiate_noexcept",
"(",
"decl",
")",
";",
"if",
"(",
"(",
"decl_maybe_constant_var_p",
"(",
"decl",
")",
"||",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
"&&",
"DECL_DECLARED_CONSTEXPR_P",
"(",
"decl",
")",
")",
")",
"&&",
"DECL_LANG_SPECIFIC",
"(",
"decl",
")",
"&&",
"DECL_TEMPLATE_INFO",
"(",
"decl",
")",
"&&",
"!",
"uses_template_parms",
"(",
"DECL_TI_ARGS",
"(",
"decl",
")",
")",
")",
"{",
"++",
"function_depth",
";",
"instantiate_decl",
"(",
"decl",
",",
"false",
",",
"false",
")",
";",
"--",
"function_depth",
";",
"}",
"if",
"(",
"cp_unevaluated_operand",
"!=",
"0",
")",
"return",
"true",
";",
"if",
"(",
"processing_template_decl",
")",
"return",
"true",
";",
"if",
"(",
"DECL_TEMPLATE_INFO",
"(",
"decl",
")",
"&&",
"uses_template_parms",
"(",
"DECL_TI_ARGS",
"(",
"decl",
")",
")",
")",
"return",
"true",
";",
"DECL_ODR_USED",
"(",
"decl",
")",
"=",
"1",
";",
"if",
"(",
"DECL_CLONED_FUNCTION_P",
"(",
"decl",
")",
")",
"DECL_ODR_USED",
"(",
"DECL_CLONED_FUNCTION",
"(",
"decl",
")",
")",
"=",
"1",
";",
"if",
"(",
"cxx_dialect",
">",
"cxx98",
"&&",
"decl_linkage",
"(",
"decl",
")",
"!=",
"lk_none",
"&&",
"!",
"DECL_EXTERN_C_P",
"(",
"decl",
")",
"&&",
"!",
"DECL_ARTIFICIAL",
"(",
"decl",
")",
"&&",
"!",
"decl_defined_p",
"(",
"decl",
")",
"&&",
"no_linkage_check",
"(",
"TREE_TYPE",
"(",
"decl",
")",
",",
"false",
")",
")",
"{",
"if",
"(",
"is_local_extern",
"(",
"decl",
")",
")",
"no_linkage_error",
"(",
"decl",
")",
";",
"else",
"VEC_safe_push",
"(",
"tree",
",",
"gc",
",",
"no_linkage_decls",
",",
"decl",
")",
";",
"}",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
"&&",
"DECL_DECLARED_INLINE_P",
"(",
"decl",
")",
"&&",
"!",
"DECL_INITIAL",
"(",
"decl",
")",
"&&",
"!",
"DECL_ARTIFICIAL",
"(",
"decl",
")",
")",
"note_vague_linkage_fn",
"(",
"decl",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
"&&",
"DECL_NONSTATIC_MEMBER_FUNCTION_P",
"(",
"decl",
")",
"&&",
"DECL_DEFAULTED_FN",
"(",
"decl",
")",
"&&",
"!",
"DECL_DEFAULTED_OUTSIDE_CLASS_P",
"(",
"decl",
")",
"&&",
"!",
"DECL_INITIAL",
"(",
"decl",
")",
")",
"{",
"if",
"(",
"DECL_VIRTUAL_P",
"(",
"decl",
")",
"&&",
"!",
"at_eof",
")",
"{",
"note_vague_linkage_fn",
"(",
"decl",
")",
";",
"return",
"true",
";",
"}",
"DECL_SOURCE_LOCATION",
"(",
"decl",
")",
"=",
"input_location",
";",
"++",
"function_depth",
";",
"synthesize_method",
"(",
"decl",
")",
";",
"--",
"function_depth",
";",
"}",
"else",
"if",
"(",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
"||",
"TREE_CODE",
"(",
"decl",
")",
"==",
"VAR_DECL",
")",
"&&",
"DECL_TEMPLATE_INFO",
"(",
"decl",
")",
"&&",
"(",
"!",
"DECL_EXPLICIT_INSTANTIATION",
"(",
"decl",
")",
"||",
"always_instantiate_p",
"(",
"decl",
")",
")",
")",
"{",
"++",
"function_depth",
";",
"instantiate_decl",
"(",
"decl",
",",
"true",
",",
"false",
")",
";",
"--",
"function_depth",
";",
"}",
"return",
"true",
";",
"}"
] | Mark DECL (either a _DECL or a BASELINK) as "used" in the program. | [
"Mark",
"DECL",
"(",
"either",
"a",
"_DECL",
"or",
"a",
"BASELINK",
")",
"as",
"\"",
"used",
"\"",
"in",
"the",
"program",
"."
] | [
"/* If DECL is a BASELINK for a single function, then treat it just\n like the DECL for the function. Otherwise, if the BASELINK is\n for an overloaded function, we don't know which function was\n actually used until after overload resolution. */",
"/* Set TREE_USED for the benefit of -Wunused. */",
"/* We mark a lambda conversion op as deleted if we can't\n\t\t generate it properly; see maybe_add_lambda_conv_op. */",
"/* We can only check DECL_ODR_USED on variables or functions with\n DECL_LANG_SPECIFIC set, and these are also the only decls that we\n might need special handling for. */",
"/* We only want to do this processing once. We don't need to keep trying\n to instantiate inline templates, because unit-at-a-time will make sure\n we get them compiled before functions that want to inline them. */",
"/* If within finish_function, defer the rest until that function\n finishes, otherwise it might recurse. */",
"/* Normally, we can wait until instantiation-time to synthesize DECL.\n However, if DECL is a static data member initialized with a constant\n or a constexpr function, we need it right now because a reference to\n such a data member or a call to such function is not value-dependent. */",
"/* Instantiating a function will result in garbage collection. We\n\t must treat this situation as if we were within the body of a\n\t function so as to avoid collecting live data only referenced from\n\t the stack (such as overload resolution candidates). */",
"/*defer_ok=*/",
"/*expl_inst_class_mem_p=*/",
"/* If we don't need a value, then we don't need to synthesize DECL. */",
"/* Check this too in case we're within fold_non_dependent_expr. */",
"/* DR 757: A type without linkage shall not be used as the type of a\n variable or function with linkage, unless\n o the variable or function has extern \"C\" linkage (7.5 [dcl.link]), or\n o the variable or function is not used (3.2 [basic.def.odr]) or is\n defined in the same translation unit. */",
"/*relaxed_p=*/",
"/* There's no way to define a local extern, and adding it to\n\t the vector interferes with GC, so give an error now. */",
"/* Remember it, so we can check it was defined. */",
"/* Is it a synthesized method that needs to be synthesized? */",
"/* A function defaulted outside the class is synthesized either by\n\t cp_finish_decl or instantiate_decl. */",
"/* Defer virtual destructors so that thunks get the right\n\t linkage. */",
"/* Remember the current location for a function we will end up\n\t synthesizing. Then we can inform the user where it was\n\t required in the case of error. */",
"/* Synthesizing an implicitly defined member function will result in\n\t garbage collection. We must treat this situation as if we were\n\t within the body of a function so as to avoid collecting live data\n\t on the stack (such as overload resolution candidates).\n\n We could just let cp_write_global_declarations handle synthesizing\n this function by adding it to deferred_fns, but doing\n it at the use site produces better error messages. */",
"/* If this is a synthesized method we don't need to\n\t do the instantiation test below. */",
"/* If this is a function or variable that is an instance of some\n template, we now know that we will need to actually do the\n instantiation. We check that DECL is not an explicit\n instantiation because that is not checked in instantiate_decl.\n\n We put off instantiating functions in order to improve compile\n times. Maintaining a stack of active functions is expensive,\n and the inliner knows to instantiate any functions it might\n need. Therefore, we always try to defer instantiation. */",
"/*defer_ok=*/",
"/*expl_inst_class_mem_p=*/"
] | [
{
"param": "decl",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "decl",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
af11ac3a6e324d635b8abbacdc9015f07cb37c37 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/libcpp/mkdeps.c | [
"BSD-3-Clause"
] | C | apply_vpath | char | static const char *
apply_vpath (struct deps *d, const char *t)
{
if (d->vpathv)
{
unsigned int i;
for (i = 0; i < d->nvpaths; i++)
{
if (!filename_ncmp (d->vpathv[i], t, d->vpathlv[i]))
{
const char *p = t + d->vpathlv[i];
if (!IS_DIR_SEPARATOR (*p))
goto not_this_one;
/* Do not simplify $(vpath)/../whatever. ??? Might not
be necessary. */
if (p[1] == '.' && p[2] == '.' && IS_DIR_SEPARATOR (p[3]))
goto not_this_one;
/* found a match */
t = t + d->vpathlv[i] + 1;
break;
}
not_this_one:;
}
}
/* Remove leading ./ in any case. */
while (t[0] == '.' && IS_DIR_SEPARATOR (t[1]))
{
t += 2;
/* If we removed a leading ./, then also remove any /s after the
first. */
while (IS_DIR_SEPARATOR (t[0]))
++t;
}
return t;
} | /* If T begins with any of the partial pathnames listed in d->vpathv,
then advance T to point beyond that pathname. */ | If T begins with any of the partial pathnames listed in d->vpathv,
then advance T to point beyond that pathname. | [
"If",
"T",
"begins",
"with",
"any",
"of",
"the",
"partial",
"pathnames",
"listed",
"in",
"d",
"-",
">",
"vpathv",
"then",
"advance",
"T",
"to",
"point",
"beyond",
"that",
"pathname",
"."
] | static const char *
apply_vpath (struct deps *d, const char *t)
{
if (d->vpathv)
{
unsigned int i;
for (i = 0; i < d->nvpaths; i++)
{
if (!filename_ncmp (d->vpathv[i], t, d->vpathlv[i]))
{
const char *p = t + d->vpathlv[i];
if (!IS_DIR_SEPARATOR (*p))
goto not_this_one;
if (p[1] == '.' && p[2] == '.' && IS_DIR_SEPARATOR (p[3]))
goto not_this_one;
t = t + d->vpathlv[i] + 1;
break;
}
not_this_one:;
}
}
while (t[0] == '.' && IS_DIR_SEPARATOR (t[1]))
{
t += 2;
while (IS_DIR_SEPARATOR (t[0]))
++t;
}
return t;
} | [
"static",
"const",
"char",
"*",
"apply_vpath",
"(",
"struct",
"deps",
"*",
"d",
",",
"const",
"char",
"*",
"t",
")",
"{",
"if",
"(",
"d",
"->",
"vpathv",
")",
"{",
"unsigned",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"d",
"->",
"nvpaths",
";",
"i",
"++",
")",
"{",
"if",
"(",
"!",
"filename_ncmp",
"(",
"d",
"->",
"vpathv",
"[",
"i",
"]",
",",
"t",
",",
"d",
"->",
"vpathlv",
"[",
"i",
"]",
")",
")",
"{",
"const",
"char",
"*",
"p",
"=",
"t",
"+",
"d",
"->",
"vpathlv",
"[",
"i",
"]",
";",
"if",
"(",
"!",
"IS_DIR_SEPARATOR",
"(",
"*",
"p",
")",
")",
"goto",
"not_this_one",
";",
"if",
"(",
"p",
"[",
"1",
"]",
"==",
"'",
"'",
"&&",
"p",
"[",
"2",
"]",
"==",
"'",
"'",
"&&",
"IS_DIR_SEPARATOR",
"(",
"p",
"[",
"3",
"]",
")",
")",
"goto",
"not_this_one",
";",
"t",
"=",
"t",
"+",
"d",
"->",
"vpathlv",
"[",
"i",
"]",
"+",
"1",
";",
"break",
";",
"}",
"not_this_one",
":",
";",
"}",
"}",
"while",
"(",
"t",
"[",
"0",
"]",
"==",
"'",
"'",
"&&",
"IS_DIR_SEPARATOR",
"(",
"t",
"[",
"1",
"]",
")",
")",
"{",
"t",
"+=",
"2",
";",
"while",
"(",
"IS_DIR_SEPARATOR",
"(",
"t",
"[",
"0",
"]",
")",
")",
"++",
"t",
";",
"}",
"return",
"t",
";",
"}"
] | If T begins with any of the partial pathnames listed in d->vpathv,
then advance T to point beyond that pathname. | [
"If",
"T",
"begins",
"with",
"any",
"of",
"the",
"partial",
"pathnames",
"listed",
"in",
"d",
"-",
">",
"vpathv",
"then",
"advance",
"T",
"to",
"point",
"beyond",
"that",
"pathname",
"."
] | [
"/* Do not simplify $(vpath)/../whatever. ??? Might not\n\t\t be necessary. */",
"/* found a match */",
"/* Remove leading ./ in any case. */",
"/* If we removed a leading ./, then also remove any /s after the\n\t first. */"
] | [
{
"param": "d",
"type": "struct deps"
},
{
"param": "t",
"type": "char"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "d",
"type": "struct deps",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "t",
"type": "char",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
af11ac3a6e324d635b8abbacdc9015f07cb37c37 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/libcpp/mkdeps.c | [
"BSD-3-Clause"
] | C | deps_add_default_target | void | void
deps_add_default_target (struct deps *d, const char *tgt)
{
/* Only if we have no targets. */
if (d->ntargets)
return;
if (tgt[0] == '\0')
deps_add_target (d, "-", 1);
else
{
#ifndef TARGET_OBJECT_SUFFIX
# define TARGET_OBJECT_SUFFIX ".o"
#endif
const char *start = lbasename (tgt);
char *o = (char *) alloca (strlen (start)
+ strlen (TARGET_OBJECT_SUFFIX) + 1);
char *suffix;
strcpy (o, start);
suffix = strrchr (o, '.');
if (!suffix)
suffix = o + strlen (o);
strcpy (suffix, TARGET_OBJECT_SUFFIX);
deps_add_target (d, o, 1);
}
} | /* Sets the default target if none has been given already. An empty
string as the default target in interpreted as stdin. The string
is quoted for MAKE. */ | Sets the default target if none has been given already. An empty
string as the default target in interpreted as stdin. The string
is quoted for MAKE. | [
"Sets",
"the",
"default",
"target",
"if",
"none",
"has",
"been",
"given",
"already",
".",
"An",
"empty",
"string",
"as",
"the",
"default",
"target",
"in",
"interpreted",
"as",
"stdin",
".",
"The",
"string",
"is",
"quoted",
"for",
"MAKE",
"."
] | void
deps_add_default_target (struct deps *d, const char *tgt)
{
if (d->ntargets)
return;
if (tgt[0] == '\0')
deps_add_target (d, "-", 1);
else
{
#ifndef TARGET_OBJECT_SUFFIX
# define TARGET_OBJECT_SUFFIX ".o"
#endif
const char *start = lbasename (tgt);
char *o = (char *) alloca (strlen (start)
+ strlen (TARGET_OBJECT_SUFFIX) + 1);
char *suffix;
strcpy (o, start);
suffix = strrchr (o, '.');
if (!suffix)
suffix = o + strlen (o);
strcpy (suffix, TARGET_OBJECT_SUFFIX);
deps_add_target (d, o, 1);
}
} | [
"void",
"deps_add_default_target",
"(",
"struct",
"deps",
"*",
"d",
",",
"const",
"char",
"*",
"tgt",
")",
"{",
"if",
"(",
"d",
"->",
"ntargets",
")",
"return",
";",
"if",
"(",
"tgt",
"[",
"0",
"]",
"==",
"'",
"\\0",
"'",
")",
"deps_add_target",
"(",
"d",
",",
"\"",
"\"",
",",
"1",
")",
";",
"else",
"{",
"#ifndef",
"TARGET_OBJECT_SUFFIX",
"# define",
"TARGET_OBJECT_SUFFIX",
" \".o\"",
"\n",
"#endif",
"const",
"char",
"*",
"start",
"=",
"lbasename",
"(",
"tgt",
")",
";",
"char",
"*",
"o",
"=",
"(",
"char",
"*",
")",
"alloca",
"(",
"strlen",
"(",
"start",
")",
"+",
"strlen",
"(",
"TARGET_OBJECT_SUFFIX",
")",
"+",
"1",
")",
";",
"char",
"*",
"suffix",
";",
"strcpy",
"(",
"o",
",",
"start",
")",
";",
"suffix",
"=",
"strrchr",
"(",
"o",
",",
"'",
"'",
")",
";",
"if",
"(",
"!",
"suffix",
")",
"suffix",
"=",
"o",
"+",
"strlen",
"(",
"o",
")",
";",
"strcpy",
"(",
"suffix",
",",
"TARGET_OBJECT_SUFFIX",
")",
";",
"deps_add_target",
"(",
"d",
",",
"o",
",",
"1",
")",
";",
"}",
"}"
] | Sets the default target if none has been given already. | [
"Sets",
"the",
"default",
"target",
"if",
"none",
"has",
"been",
"given",
"already",
"."
] | [
"/* Only if we have no targets. */"
] | [
{
"param": "d",
"type": "struct deps"
},
{
"param": "tgt",
"type": "char"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "d",
"type": "struct deps",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "tgt",
"type": "char",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
af11ac3a6e324d635b8abbacdc9015f07cb37c37 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/libcpp/mkdeps.c | [
"BSD-3-Clause"
] | C | deps_save | int | int
deps_save (struct deps *deps, FILE *f)
{
unsigned int i;
/* The cppreader structure contains makefile dependences. Write out this
structure. */
/* The number of dependences. */
if (fwrite (&deps->ndeps, sizeof (deps->ndeps), 1, f) != 1)
return -1;
/* The length of each dependence followed by the string. */
for (i = 0; i < deps->ndeps; i++)
{
size_t num_to_write = strlen (deps->depv[i]);
if (fwrite (&num_to_write, sizeof (size_t), 1, f) != 1)
return -1;
if (fwrite (deps->depv[i], num_to_write, 1, f) != 1)
return -1;
}
return 0;
} | /* Write out a deps buffer to a file, in a form that can be read back
with deps_restore. Returns nonzero on error, in which case the
error number will be in errno. */ | Write out a deps buffer to a file, in a form that can be read back
with deps_restore. Returns nonzero on error, in which case the
error number will be in errno. | [
"Write",
"out",
"a",
"deps",
"buffer",
"to",
"a",
"file",
"in",
"a",
"form",
"that",
"can",
"be",
"read",
"back",
"with",
"deps_restore",
".",
"Returns",
"nonzero",
"on",
"error",
"in",
"which",
"case",
"the",
"error",
"number",
"will",
"be",
"in",
"errno",
"."
] | int
deps_save (struct deps *deps, FILE *f)
{
unsigned int i;
if (fwrite (&deps->ndeps, sizeof (deps->ndeps), 1, f) != 1)
return -1;
for (i = 0; i < deps->ndeps; i++)
{
size_t num_to_write = strlen (deps->depv[i]);
if (fwrite (&num_to_write, sizeof (size_t), 1, f) != 1)
return -1;
if (fwrite (deps->depv[i], num_to_write, 1, f) != 1)
return -1;
}
return 0;
} | [
"int",
"deps_save",
"(",
"struct",
"deps",
"*",
"deps",
",",
"FILE",
"*",
"f",
")",
"{",
"unsigned",
"int",
"i",
";",
"if",
"(",
"fwrite",
"(",
"&",
"deps",
"->",
"ndeps",
",",
"sizeof",
"(",
"deps",
"->",
"ndeps",
")",
",",
"1",
",",
"f",
")",
"!=",
"1",
")",
"return",
"-1",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"deps",
"->",
"ndeps",
";",
"i",
"++",
")",
"{",
"size_t",
"num_to_write",
"=",
"strlen",
"(",
"deps",
"->",
"depv",
"[",
"i",
"]",
")",
";",
"if",
"(",
"fwrite",
"(",
"&",
"num_to_write",
",",
"sizeof",
"(",
"size_t",
")",
",",
"1",
",",
"f",
")",
"!=",
"1",
")",
"return",
"-1",
";",
"if",
"(",
"fwrite",
"(",
"deps",
"->",
"depv",
"[",
"i",
"]",
",",
"num_to_write",
",",
"1",
",",
"f",
")",
"!=",
"1",
")",
"return",
"-1",
";",
"}",
"return",
"0",
";",
"}"
] | Write out a deps buffer to a file, in a form that can be read back
with deps_restore. | [
"Write",
"out",
"a",
"deps",
"buffer",
"to",
"a",
"file",
"in",
"a",
"form",
"that",
"can",
"be",
"read",
"back",
"with",
"deps_restore",
"."
] | [
"/* The cppreader structure contains makefile dependences. Write out this\n structure. */",
"/* The number of dependences. */",
"/* The length of each dependence followed by the string. */"
] | [
{
"param": "deps",
"type": "struct deps"
},
{
"param": "f",
"type": "FILE"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "deps",
"type": "struct deps",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "f",
"type": "FILE",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
af11ac3a6e324d635b8abbacdc9015f07cb37c37 | atrens/DragonFlyBSD-src | contrib/gcc-4.7/libcpp/mkdeps.c | [
"BSD-3-Clause"
] | C | deps_restore | int | int
deps_restore (struct deps *deps, FILE *fd, const char *self)
{
unsigned int i, count;
size_t num_to_read;
size_t buf_size = 512;
char *buf = XNEWVEC (char, buf_size);
/* Number of dependences. */
if (fread (&count, 1, sizeof (count), fd) != sizeof (count))
return -1;
/* The length of each dependence string, followed by the string. */
for (i = 0; i < count; i++)
{
/* Read in # bytes in string. */
if (fread (&num_to_read, 1, sizeof (size_t), fd) != sizeof (size_t))
return -1;
if (buf_size < num_to_read + 1)
{
buf_size = num_to_read + 1 + 127;
buf = XRESIZEVEC (char, buf, buf_size);
}
if (fread (buf, 1, num_to_read, fd) != num_to_read)
return -1;
buf[num_to_read] = '\0';
/* Generate makefile dependencies from .pch if -nopch-deps. */
if (self != NULL && filename_cmp (buf, self) != 0)
deps_add_dep (deps, buf);
}
free (buf);
return 0;
} | /* Read back dependency information written with deps_save into
the deps buffer. The third argument may be NULL, in which case
the dependency information is just skipped, or it may be a filename,
in which case that filename is skipped. */ | Read back dependency information written with deps_save into
the deps buffer. The third argument may be NULL, in which case
the dependency information is just skipped, or it may be a filename,
in which case that filename is skipped. | [
"Read",
"back",
"dependency",
"information",
"written",
"with",
"deps_save",
"into",
"the",
"deps",
"buffer",
".",
"The",
"third",
"argument",
"may",
"be",
"NULL",
"in",
"which",
"case",
"the",
"dependency",
"information",
"is",
"just",
"skipped",
"or",
"it",
"may",
"be",
"a",
"filename",
"in",
"which",
"case",
"that",
"filename",
"is",
"skipped",
"."
] | int
deps_restore (struct deps *deps, FILE *fd, const char *self)
{
unsigned int i, count;
size_t num_to_read;
size_t buf_size = 512;
char *buf = XNEWVEC (char, buf_size);
if (fread (&count, 1, sizeof (count), fd) != sizeof (count))
return -1;
for (i = 0; i < count; i++)
{
if (fread (&num_to_read, 1, sizeof (size_t), fd) != sizeof (size_t))
return -1;
if (buf_size < num_to_read + 1)
{
buf_size = num_to_read + 1 + 127;
buf = XRESIZEVEC (char, buf, buf_size);
}
if (fread (buf, 1, num_to_read, fd) != num_to_read)
return -1;
buf[num_to_read] = '\0';
if (self != NULL && filename_cmp (buf, self) != 0)
deps_add_dep (deps, buf);
}
free (buf);
return 0;
} | [
"int",
"deps_restore",
"(",
"struct",
"deps",
"*",
"deps",
",",
"FILE",
"*",
"fd",
",",
"const",
"char",
"*",
"self",
")",
"{",
"unsigned",
"int",
"i",
",",
"count",
";",
"size_t",
"num_to_read",
";",
"size_t",
"buf_size",
"=",
"512",
";",
"char",
"*",
"buf",
"=",
"XNEWVEC",
"(",
"char",
",",
"buf_size",
")",
";",
"if",
"(",
"fread",
"(",
"&",
"count",
",",
"1",
",",
"sizeof",
"(",
"count",
")",
",",
"fd",
")",
"!=",
"sizeof",
"(",
"count",
")",
")",
"return",
"-1",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"count",
";",
"i",
"++",
")",
"{",
"if",
"(",
"fread",
"(",
"&",
"num_to_read",
",",
"1",
",",
"sizeof",
"(",
"size_t",
")",
",",
"fd",
")",
"!=",
"sizeof",
"(",
"size_t",
")",
")",
"return",
"-1",
";",
"if",
"(",
"buf_size",
"<",
"num_to_read",
"+",
"1",
")",
"{",
"buf_size",
"=",
"num_to_read",
"+",
"1",
"+",
"127",
";",
"buf",
"=",
"XRESIZEVEC",
"(",
"char",
",",
"buf",
",",
"buf_size",
")",
";",
"}",
"if",
"(",
"fread",
"(",
"buf",
",",
"1",
",",
"num_to_read",
",",
"fd",
")",
"!=",
"num_to_read",
")",
"return",
"-1",
";",
"buf",
"[",
"num_to_read",
"]",
"=",
"'",
"\\0",
"'",
";",
"if",
"(",
"self",
"!=",
"NULL",
"&&",
"filename_cmp",
"(",
"buf",
",",
"self",
")",
"!=",
"0",
")",
"deps_add_dep",
"(",
"deps",
",",
"buf",
")",
";",
"}",
"free",
"(",
"buf",
")",
";",
"return",
"0",
";",
"}"
] | Read back dependency information written with deps_save into
the deps buffer. | [
"Read",
"back",
"dependency",
"information",
"written",
"with",
"deps_save",
"into",
"the",
"deps",
"buffer",
"."
] | [
"/* Number of dependences. */",
"/* The length of each dependence string, followed by the string. */",
"/* Read in # bytes in string. */",
"/* Generate makefile dependencies from .pch if -nopch-deps. */"
] | [
{
"param": "deps",
"type": "struct deps"
},
{
"param": "fd",
"type": "FILE"
},
{
"param": "self",
"type": "char"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "deps",
"type": "struct deps",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "fd",
"type": "FILE",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "self",
"type": "char",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
33a45781ecf17ed02cbd5b6ea0585d9d06eb4afa | atrens/DragonFlyBSD-src | games/boggle/boggle/bog.c | [
"BSD-3-Clause"
] | C | batchword | char | char *
batchword(FILE *fp)
{
int *p, *q;
char *w;
q = &wordpath[MAXWORDLEN + 1];
p = wordpath;
while (p < q)
*p++ = -1;
while ((w = nextword(fp)) != NULL) {
if (wordlen < minlength)
continue;
p = wordpath;
while (p < q && *p != -1)
*p++ = -1;
usedbits = 0;
if (checkword(w, -1, wordpath) != -1)
return (w);
}
return (NULL);
} | /*
* Read a line from the given stream and check if it is legal
* Return a pointer to a legal word or a null pointer when EOF is reached
*/ | Read a line from the given stream and check if it is legal
Return a pointer to a legal word or a null pointer when EOF is reached | [
"Read",
"a",
"line",
"from",
"the",
"given",
"stream",
"and",
"check",
"if",
"it",
"is",
"legal",
"Return",
"a",
"pointer",
"to",
"a",
"legal",
"word",
"or",
"a",
"null",
"pointer",
"when",
"EOF",
"is",
"reached"
] | char *
batchword(FILE *fp)
{
int *p, *q;
char *w;
q = &wordpath[MAXWORDLEN + 1];
p = wordpath;
while (p < q)
*p++ = -1;
while ((w = nextword(fp)) != NULL) {
if (wordlen < minlength)
continue;
p = wordpath;
while (p < q && *p != -1)
*p++ = -1;
usedbits = 0;
if (checkword(w, -1, wordpath) != -1)
return (w);
}
return (NULL);
} | [
"char",
"*",
"batchword",
"(",
"FILE",
"*",
"fp",
")",
"{",
"int",
"*",
"p",
",",
"*",
"q",
";",
"char",
"*",
"w",
";",
"q",
"=",
"&",
"wordpath",
"[",
"MAXWORDLEN",
"+",
"1",
"]",
";",
"p",
"=",
"wordpath",
";",
"while",
"(",
"p",
"<",
"q",
")",
"*",
"p",
"++",
"=",
"-1",
";",
"while",
"(",
"(",
"w",
"=",
"nextword",
"(",
"fp",
")",
")",
"!=",
"NULL",
")",
"{",
"if",
"(",
"wordlen",
"<",
"minlength",
")",
"continue",
";",
"p",
"=",
"wordpath",
";",
"while",
"(",
"p",
"<",
"q",
"&&",
"*",
"p",
"!=",
"-1",
")",
"*",
"p",
"++",
"=",
"-1",
";",
"usedbits",
"=",
"0",
";",
"if",
"(",
"checkword",
"(",
"w",
",",
"-1",
",",
"wordpath",
")",
"!=",
"-1",
")",
"return",
"(",
"w",
")",
";",
"}",
"return",
"(",
"NULL",
")",
";",
"}"
] | Read a line from the given stream and check if it is legal
Return a pointer to a legal word or a null pointer when EOF is reached | [
"Read",
"a",
"line",
"from",
"the",
"given",
"stream",
"and",
"check",
"if",
"it",
"is",
"legal",
"Return",
"a",
"pointer",
"to",
"a",
"legal",
"word",
"or",
"a",
"null",
"pointer",
"when",
"EOF",
"is",
"reached"
] | [] | [
{
"param": "fp",
"type": "FILE"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "fp",
"type": "FILE",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
33a45781ecf17ed02cbd5b6ea0585d9d06eb4afa | atrens/DragonFlyBSD-src | games/boggle/boggle/bog.c | [
"BSD-3-Clause"
] | C | playgame | void | void
playgame(void)
{
int i, *p, *q;
time_t t;
char buf[MAXWORDLEN + 1];
ngames++;
npwords = 0;
pwordsp = pwords;
nmwords = 0;
mwordsp = mwords;
time(&start_t);
q = &wordpath[MAXWORDLEN + 1];
p = wordpath;
while (p < q)
*p++ = -1;
showboard(board);
startwords();
if (setjmp(env)) {
badword();
goto timesup;
}
while (1) {
if (get_line(buf) == NULL) {
if (feof(stdin))
clearerr(stdin);
break;
}
time(&t);
if (t - start_t >= tlimit) {
badword();
break;
}
if (buf[0] == '\0') {
int remaining;
remaining = tlimit - (int) (t - start_t);
snprintf(buf, sizeof(buf),
"%d:%02d", remaining / 60, remaining % 60);
showstr(buf, 1);
continue;
}
if (strlen(buf) < (size_t)minlength) {
badword();
continue;
}
p = wordpath;
while (p < q && *p != -1)
*p++ = -1;
usedbits = 0;
if (checkword(buf, -1, wordpath) < 0)
badword();
else {
if (debug) {
printf("[");
for (i = 0; wordpath[i] != -1; i++)
printf(" %d", wordpath[i]);
printf(" ]\n");
}
for (i = 0; i < npwords; i++) {
if (strcmp(pword[i], buf) == 0)
break;
}
if (i != npwords) { /* already used the word */
badword();
showword(i);
}
else if (!validword(buf))
badword();
else {
int len;
if (npwords == maxpwords - 1) {
maxpwords += MAXPWORDS;
pword = realloc(pword,
maxpwords * sizeof(char *));
if (pword == NULL) {
cleanup();
errx(1, "%s", strerror(ENOMEM));
}
}
len = strlen(buf) + 1;
if (pwordsp + len >= &pwords[maxpspace]) {
maxpspace += MAXPSPACE;
pwords = realloc(pwords, maxpspace);
if (pwords == NULL) {
cleanup();
errx(1, "%s", strerror(ENOMEM));
}
}
pword[npwords++] = pwordsp;
memcpy(pwordsp, buf, len);
pwordsp += len;
addword(buf);
}
}
}
timesup: ;
/*
* Sort the player's words and terminate the list with a null
* entry to help out checkdict()
*/
qsort(pword, npwords, sizeof(pword[0]), compar);
pword[npwords] = NULL;
/*
* These words don't need to be sorted since the dictionary is sorted
*/
checkdict();
tnmwords += nmwords;
tnpwords += npwords;
results();
} | /*
* Play a single game
* Reset the word lists from last game
* Keep track of the running stats
*/ | Play a single game
Reset the word lists from last game
Keep track of the running stats | [
"Play",
"a",
"single",
"game",
"Reset",
"the",
"word",
"lists",
"from",
"last",
"game",
"Keep",
"track",
"of",
"the",
"running",
"stats"
] | void
playgame(void)
{
int i, *p, *q;
time_t t;
char buf[MAXWORDLEN + 1];
ngames++;
npwords = 0;
pwordsp = pwords;
nmwords = 0;
mwordsp = mwords;
time(&start_t);
q = &wordpath[MAXWORDLEN + 1];
p = wordpath;
while (p < q)
*p++ = -1;
showboard(board);
startwords();
if (setjmp(env)) {
badword();
goto timesup;
}
while (1) {
if (get_line(buf) == NULL) {
if (feof(stdin))
clearerr(stdin);
break;
}
time(&t);
if (t - start_t >= tlimit) {
badword();
break;
}
if (buf[0] == '\0') {
int remaining;
remaining = tlimit - (int) (t - start_t);
snprintf(buf, sizeof(buf),
"%d:%02d", remaining / 60, remaining % 60);
showstr(buf, 1);
continue;
}
if (strlen(buf) < (size_t)minlength) {
badword();
continue;
}
p = wordpath;
while (p < q && *p != -1)
*p++ = -1;
usedbits = 0;
if (checkword(buf, -1, wordpath) < 0)
badword();
else {
if (debug) {
printf("[");
for (i = 0; wordpath[i] != -1; i++)
printf(" %d", wordpath[i]);
printf(" ]\n");
}
for (i = 0; i < npwords; i++) {
if (strcmp(pword[i], buf) == 0)
break;
}
if (i != npwords) {
badword();
showword(i);
}
else if (!validword(buf))
badword();
else {
int len;
if (npwords == maxpwords - 1) {
maxpwords += MAXPWORDS;
pword = realloc(pword,
maxpwords * sizeof(char *));
if (pword == NULL) {
cleanup();
errx(1, "%s", strerror(ENOMEM));
}
}
len = strlen(buf) + 1;
if (pwordsp + len >= &pwords[maxpspace]) {
maxpspace += MAXPSPACE;
pwords = realloc(pwords, maxpspace);
if (pwords == NULL) {
cleanup();
errx(1, "%s", strerror(ENOMEM));
}
}
pword[npwords++] = pwordsp;
memcpy(pwordsp, buf, len);
pwordsp += len;
addword(buf);
}
}
}
timesup: ;
qsort(pword, npwords, sizeof(pword[0]), compar);
pword[npwords] = NULL;
checkdict();
tnmwords += nmwords;
tnpwords += npwords;
results();
} | [
"void",
"playgame",
"(",
"void",
")",
"{",
"int",
"i",
",",
"*",
"p",
",",
"*",
"q",
";",
"time_t",
"t",
";",
"char",
"buf",
"[",
"MAXWORDLEN",
"+",
"1",
"]",
";",
"ngames",
"++",
";",
"npwords",
"=",
"0",
";",
"pwordsp",
"=",
"pwords",
";",
"nmwords",
"=",
"0",
";",
"mwordsp",
"=",
"mwords",
";",
"time",
"(",
"&",
"start_t",
")",
";",
"q",
"=",
"&",
"wordpath",
"[",
"MAXWORDLEN",
"+",
"1",
"]",
";",
"p",
"=",
"wordpath",
";",
"while",
"(",
"p",
"<",
"q",
")",
"*",
"p",
"++",
"=",
"-1",
";",
"showboard",
"(",
"board",
")",
";",
"startwords",
"(",
")",
";",
"if",
"(",
"setjmp",
"(",
"env",
")",
")",
"{",
"badword",
"(",
")",
";",
"goto",
"timesup",
";",
"}",
"while",
"(",
"1",
")",
"{",
"if",
"(",
"get_line",
"(",
"buf",
")",
"==",
"NULL",
")",
"{",
"if",
"(",
"feof",
"(",
"stdin",
")",
")",
"clearerr",
"(",
"stdin",
")",
";",
"break",
";",
"}",
"time",
"(",
"&",
"t",
")",
";",
"if",
"(",
"t",
"-",
"start_t",
">=",
"tlimit",
")",
"{",
"badword",
"(",
")",
";",
"break",
";",
"}",
"if",
"(",
"buf",
"[",
"0",
"]",
"==",
"'",
"\\0",
"'",
")",
"{",
"int",
"remaining",
";",
"remaining",
"=",
"tlimit",
"-",
"(",
"int",
")",
"(",
"t",
"-",
"start_t",
")",
";",
"snprintf",
"(",
"buf",
",",
"sizeof",
"(",
"buf",
")",
",",
"\"",
"\"",
",",
"remaining",
"/",
"60",
",",
"remaining",
"%",
"60",
")",
";",
"showstr",
"(",
"buf",
",",
"1",
")",
";",
"continue",
";",
"}",
"if",
"(",
"strlen",
"(",
"buf",
")",
"<",
"(",
"size_t",
")",
"minlength",
")",
"{",
"badword",
"(",
")",
";",
"continue",
";",
"}",
"p",
"=",
"wordpath",
";",
"while",
"(",
"p",
"<",
"q",
"&&",
"*",
"p",
"!=",
"-1",
")",
"*",
"p",
"++",
"=",
"-1",
";",
"usedbits",
"=",
"0",
";",
"if",
"(",
"checkword",
"(",
"buf",
",",
"-1",
",",
"wordpath",
")",
"<",
"0",
")",
"badword",
"(",
")",
";",
"else",
"{",
"if",
"(",
"debug",
")",
"{",
"printf",
"(",
"\"",
"\"",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"wordpath",
"[",
"i",
"]",
"!=",
"-1",
";",
"i",
"++",
")",
"printf",
"(",
"\"",
"\"",
",",
"wordpath",
"[",
"i",
"]",
")",
";",
"printf",
"(",
"\"",
"\\n",
"\"",
")",
";",
"}",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"npwords",
";",
"i",
"++",
")",
"{",
"if",
"(",
"strcmp",
"(",
"pword",
"[",
"i",
"]",
",",
"buf",
")",
"==",
"0",
")",
"break",
";",
"}",
"if",
"(",
"i",
"!=",
"npwords",
")",
"{",
"badword",
"(",
")",
";",
"showword",
"(",
"i",
")",
";",
"}",
"else",
"if",
"(",
"!",
"validword",
"(",
"buf",
")",
")",
"badword",
"(",
")",
";",
"else",
"{",
"int",
"len",
";",
"if",
"(",
"npwords",
"==",
"maxpwords",
"-",
"1",
")",
"{",
"maxpwords",
"+=",
"MAXPWORDS",
";",
"pword",
"=",
"realloc",
"(",
"pword",
",",
"maxpwords",
"*",
"sizeof",
"(",
"char",
"*",
")",
")",
";",
"if",
"(",
"pword",
"==",
"NULL",
")",
"{",
"cleanup",
"(",
")",
";",
"errx",
"(",
"1",
",",
"\"",
"\"",
",",
"strerror",
"(",
"ENOMEM",
")",
")",
";",
"}",
"}",
"len",
"=",
"strlen",
"(",
"buf",
")",
"+",
"1",
";",
"if",
"(",
"pwordsp",
"+",
"len",
">=",
"&",
"pwords",
"[",
"maxpspace",
"]",
")",
"{",
"maxpspace",
"+=",
"MAXPSPACE",
";",
"pwords",
"=",
"realloc",
"(",
"pwords",
",",
"maxpspace",
")",
";",
"if",
"(",
"pwords",
"==",
"NULL",
")",
"{",
"cleanup",
"(",
")",
";",
"errx",
"(",
"1",
",",
"\"",
"\"",
",",
"strerror",
"(",
"ENOMEM",
")",
")",
";",
"}",
"}",
"pword",
"[",
"npwords",
"++",
"]",
"=",
"pwordsp",
";",
"memcpy",
"(",
"pwordsp",
",",
"buf",
",",
"len",
")",
";",
"pwordsp",
"+=",
"len",
";",
"addword",
"(",
"buf",
")",
";",
"}",
"}",
"}",
"timesup",
":",
";",
"qsort",
"(",
"pword",
",",
"npwords",
",",
"sizeof",
"(",
"pword",
"[",
"0",
"]",
")",
",",
"compar",
")",
";",
"pword",
"[",
"npwords",
"]",
"=",
"NULL",
";",
"checkdict",
"(",
")",
";",
"tnmwords",
"+=",
"nmwords",
";",
"tnpwords",
"+=",
"npwords",
";",
"results",
"(",
")",
";",
"}"
] | Play a single game
Reset the word lists from last game
Keep track of the running stats | [
"Play",
"a",
"single",
"game",
"Reset",
"the",
"word",
"lists",
"from",
"last",
"game",
"Keep",
"track",
"of",
"the",
"running",
"stats"
] | [
"/* already used the word */",
"/*\n\t * Sort the player's words and terminate the list with a null\n\t * entry to help out checkdict()\n\t */",
"/*\n\t * These words don't need to be sorted since the dictionary is sorted\n\t */"
] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
33a45781ecf17ed02cbd5b6ea0585d9d06eb4afa | atrens/DragonFlyBSD-src | games/boggle/boggle/bog.c | [
"BSD-3-Clause"
] | C | validword | int | int
validword(char *word)
{
int j;
char *q, *w;
j = word[0] - 'a';
if (dictseek(dictfp, dictindex[j].start, SEEK_SET) < 0) {
cleanup();
errx(1, "seek error in validword()");
}
while ((w = nextword(dictfp)) != NULL) {
int ch;
if (*w != word[0]) /* end of words starting with word[0] */
break;
q = word;
while ((ch = *w++) == *q++ && ch != '\0')
;
if (*(w - 1) == '\0' && *(q - 1) == '\0')
return (1);
}
if (dictfp != NULL && feof(dictfp)) /* Special case for z's */
clearerr(dictfp);
return (0);
} | /*
* A word is invalid if it is not in the dictionary
* At this point it is already known that the word can be formed from
* the current board
*/ | A word is invalid if it is not in the dictionary
At this point it is already known that the word can be formed from
the current board | [
"A",
"word",
"is",
"invalid",
"if",
"it",
"is",
"not",
"in",
"the",
"dictionary",
"At",
"this",
"point",
"it",
"is",
"already",
"known",
"that",
"the",
"word",
"can",
"be",
"formed",
"from",
"the",
"current",
"board"
] | int
validword(char *word)
{
int j;
char *q, *w;
j = word[0] - 'a';
if (dictseek(dictfp, dictindex[j].start, SEEK_SET) < 0) {
cleanup();
errx(1, "seek error in validword()");
}
while ((w = nextword(dictfp)) != NULL) {
int ch;
if (*w != word[0])
break;
q = word;
while ((ch = *w++) == *q++ && ch != '\0')
;
if (*(w - 1) == '\0' && *(q - 1) == '\0')
return (1);
}
if (dictfp != NULL && feof(dictfp))
clearerr(dictfp);
return (0);
} | [
"int",
"validword",
"(",
"char",
"*",
"word",
")",
"{",
"int",
"j",
";",
"char",
"*",
"q",
",",
"*",
"w",
";",
"j",
"=",
"word",
"[",
"0",
"]",
"-",
"'",
"'",
";",
"if",
"(",
"dictseek",
"(",
"dictfp",
",",
"dictindex",
"[",
"j",
"]",
".",
"start",
",",
"SEEK_SET",
")",
"<",
"0",
")",
"{",
"cleanup",
"(",
")",
";",
"errx",
"(",
"1",
",",
"\"",
"\"",
")",
";",
"}",
"while",
"(",
"(",
"w",
"=",
"nextword",
"(",
"dictfp",
")",
")",
"!=",
"NULL",
")",
"{",
"int",
"ch",
";",
"if",
"(",
"*",
"w",
"!=",
"word",
"[",
"0",
"]",
")",
"break",
";",
"q",
"=",
"word",
";",
"while",
"(",
"(",
"ch",
"=",
"*",
"w",
"++",
")",
"==",
"*",
"q",
"++",
"&&",
"ch",
"!=",
"'",
"\\0",
"'",
")",
";",
"if",
"(",
"*",
"(",
"w",
"-",
"1",
")",
"==",
"'",
"\\0",
"'",
"&&",
"*",
"(",
"q",
"-",
"1",
")",
"==",
"'",
"\\0",
"'",
")",
"return",
"(",
"1",
")",
";",
"}",
"if",
"(",
"dictfp",
"!=",
"NULL",
"&&",
"feof",
"(",
"dictfp",
")",
")",
"clearerr",
"(",
"dictfp",
")",
";",
"return",
"(",
"0",
")",
";",
"}"
] | A word is invalid if it is not in the dictionary
At this point it is already known that the word can be formed from
the current board | [
"A",
"word",
"is",
"invalid",
"if",
"it",
"is",
"not",
"in",
"the",
"dictionary",
"At",
"this",
"point",
"it",
"is",
"already",
"known",
"that",
"the",
"word",
"can",
"be",
"formed",
"from",
"the",
"current",
"board"
] | [
"/* end of words starting with word[0] */",
"/* Special case for z's */"
] | [
{
"param": "word",
"type": "char"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "word",
"type": "char",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
33a45781ecf17ed02cbd5b6ea0585d9d06eb4afa | atrens/DragonFlyBSD-src | games/boggle/boggle/bog.c | [
"BSD-3-Clause"
] | C | checkdict | void | void
checkdict(void)
{
char **pw, *w;
int i;
int prevch, previndex, *pi, *qi, st;
mwordsp = mwords;
nmwords = 0;
pw = pword;
prevch ='a';
qi = &wordpath[MAXWORDLEN + 1];
dictseek(dictfp, 0L, SEEK_SET);
while ((w = nextword(dictfp)) != NULL) {
if (wordlen < minlength)
continue;
if (*w != prevch) {
/*
* If we've moved on to a word with a different first
* letter then we can speed things up by skipping all
* words starting with a letter that doesn't appear in
* the cube.
*/
i = (int) (*w - 'a');
while (i < 26 && letter_map[i][0] == -1)
i++;
if (i == 26)
break;
previndex = prevch - 'a';
prevch = i + 'a';
/*
* Fall through if the word's first letter appears in
* the cube (i.e., if we can't skip ahead), otherwise
* seek to the beginning of words in the dictionary
* starting with the next letter (alphabetically)
* appearing in the cube and then read the first word.
*/
if (i != previndex + 1) {
if (dictseek(dictfp,
dictindex[i].start, SEEK_SET) < 0) {
cleanup();
errx(1, "seek error in checkdict()");
}
continue;
}
}
pi = wordpath;
while (pi < qi && *pi != -1)
*pi++ = -1;
usedbits = 0;
if (checkword(w, -1, wordpath) == -1)
continue;
st = 1;
while (*pw != NULL && (st = strcmp(*pw, w)) < 0)
pw++;
if (st == 0) /* found it */
continue;
if (nmwords == maxmwords - 1) {
maxmwords += MAXMWORDS;
mword = realloc(mword, maxmwords * sizeof(char *));
if (mword == NULL) {
cleanup();
errx(1, "%s", strerror(ENOMEM));
}
}
if (mwordsp + wordlen + 1 >= &mwords[maxmspace]) {
maxmspace += MAXMSPACE;
mwords = realloc(mwords, maxmspace);
if (mwords == NULL) {
cleanup();
errx(1, "%s", strerror(ENOMEM));
}
}
mword[nmwords++] = mwordsp;
memcpy(mwordsp, w, wordlen + 1);
mwordsp += wordlen + 1;
}
} | /*
* Check each word in the dictionary against the board
* Delete words from the machine list that the player has found
* Assume both the dictionary and the player's words are already sorted
*/ | Check each word in the dictionary against the board
Delete words from the machine list that the player has found
Assume both the dictionary and the player's words are already sorted | [
"Check",
"each",
"word",
"in",
"the",
"dictionary",
"against",
"the",
"board",
"Delete",
"words",
"from",
"the",
"machine",
"list",
"that",
"the",
"player",
"has",
"found",
"Assume",
"both",
"the",
"dictionary",
"and",
"the",
"player",
"'",
"s",
"words",
"are",
"already",
"sorted"
] | void
checkdict(void)
{
char **pw, *w;
int i;
int prevch, previndex, *pi, *qi, st;
mwordsp = mwords;
nmwords = 0;
pw = pword;
prevch ='a';
qi = &wordpath[MAXWORDLEN + 1];
dictseek(dictfp, 0L, SEEK_SET);
while ((w = nextword(dictfp)) != NULL) {
if (wordlen < minlength)
continue;
if (*w != prevch) {
i = (int) (*w - 'a');
while (i < 26 && letter_map[i][0] == -1)
i++;
if (i == 26)
break;
previndex = prevch - 'a';
prevch = i + 'a';
if (i != previndex + 1) {
if (dictseek(dictfp,
dictindex[i].start, SEEK_SET) < 0) {
cleanup();
errx(1, "seek error in checkdict()");
}
continue;
}
}
pi = wordpath;
while (pi < qi && *pi != -1)
*pi++ = -1;
usedbits = 0;
if (checkword(w, -1, wordpath) == -1)
continue;
st = 1;
while (*pw != NULL && (st = strcmp(*pw, w)) < 0)
pw++;
if (st == 0)
continue;
if (nmwords == maxmwords - 1) {
maxmwords += MAXMWORDS;
mword = realloc(mword, maxmwords * sizeof(char *));
if (mword == NULL) {
cleanup();
errx(1, "%s", strerror(ENOMEM));
}
}
if (mwordsp + wordlen + 1 >= &mwords[maxmspace]) {
maxmspace += MAXMSPACE;
mwords = realloc(mwords, maxmspace);
if (mwords == NULL) {
cleanup();
errx(1, "%s", strerror(ENOMEM));
}
}
mword[nmwords++] = mwordsp;
memcpy(mwordsp, w, wordlen + 1);
mwordsp += wordlen + 1;
}
} | [
"void",
"checkdict",
"(",
"void",
")",
"{",
"char",
"*",
"*",
"pw",
",",
"*",
"w",
";",
"int",
"i",
";",
"int",
"prevch",
",",
"previndex",
",",
"*",
"pi",
",",
"*",
"qi",
",",
"st",
";",
"mwordsp",
"=",
"mwords",
";",
"nmwords",
"=",
"0",
";",
"pw",
"=",
"pword",
";",
"prevch",
"=",
"'",
"'",
";",
"qi",
"=",
"&",
"wordpath",
"[",
"MAXWORDLEN",
"+",
"1",
"]",
";",
"dictseek",
"(",
"dictfp",
",",
"0L",
",",
"SEEK_SET",
")",
";",
"while",
"(",
"(",
"w",
"=",
"nextword",
"(",
"dictfp",
")",
")",
"!=",
"NULL",
")",
"{",
"if",
"(",
"wordlen",
"<",
"minlength",
")",
"continue",
";",
"if",
"(",
"*",
"w",
"!=",
"prevch",
")",
"{",
"i",
"=",
"(",
"int",
")",
"(",
"*",
"w",
"-",
"'",
"'",
")",
";",
"while",
"(",
"i",
"<",
"26",
"&&",
"letter_map",
"[",
"i",
"]",
"[",
"0",
"]",
"==",
"-1",
")",
"i",
"++",
";",
"if",
"(",
"i",
"==",
"26",
")",
"break",
";",
"previndex",
"=",
"prevch",
"-",
"'",
"'",
";",
"prevch",
"=",
"i",
"+",
"'",
"'",
";",
"if",
"(",
"i",
"!=",
"previndex",
"+",
"1",
")",
"{",
"if",
"(",
"dictseek",
"(",
"dictfp",
",",
"dictindex",
"[",
"i",
"]",
".",
"start",
",",
"SEEK_SET",
")",
"<",
"0",
")",
"{",
"cleanup",
"(",
")",
";",
"errx",
"(",
"1",
",",
"\"",
"\"",
")",
";",
"}",
"continue",
";",
"}",
"}",
"pi",
"=",
"wordpath",
";",
"while",
"(",
"pi",
"<",
"qi",
"&&",
"*",
"pi",
"!=",
"-1",
")",
"*",
"pi",
"++",
"=",
"-1",
";",
"usedbits",
"=",
"0",
";",
"if",
"(",
"checkword",
"(",
"w",
",",
"-1",
",",
"wordpath",
")",
"==",
"-1",
")",
"continue",
";",
"st",
"=",
"1",
";",
"while",
"(",
"*",
"pw",
"!=",
"NULL",
"&&",
"(",
"st",
"=",
"strcmp",
"(",
"*",
"pw",
",",
"w",
")",
")",
"<",
"0",
")",
"pw",
"++",
";",
"if",
"(",
"st",
"==",
"0",
")",
"continue",
";",
"if",
"(",
"nmwords",
"==",
"maxmwords",
"-",
"1",
")",
"{",
"maxmwords",
"+=",
"MAXMWORDS",
";",
"mword",
"=",
"realloc",
"(",
"mword",
",",
"maxmwords",
"*",
"sizeof",
"(",
"char",
"*",
")",
")",
";",
"if",
"(",
"mword",
"==",
"NULL",
")",
"{",
"cleanup",
"(",
")",
";",
"errx",
"(",
"1",
",",
"\"",
"\"",
",",
"strerror",
"(",
"ENOMEM",
")",
")",
";",
"}",
"}",
"if",
"(",
"mwordsp",
"+",
"wordlen",
"+",
"1",
">=",
"&",
"mwords",
"[",
"maxmspace",
"]",
")",
"{",
"maxmspace",
"+=",
"MAXMSPACE",
";",
"mwords",
"=",
"realloc",
"(",
"mwords",
",",
"maxmspace",
")",
";",
"if",
"(",
"mwords",
"==",
"NULL",
")",
"{",
"cleanup",
"(",
")",
";",
"errx",
"(",
"1",
",",
"\"",
"\"",
",",
"strerror",
"(",
"ENOMEM",
")",
")",
";",
"}",
"}",
"mword",
"[",
"nmwords",
"++",
"]",
"=",
"mwordsp",
";",
"memcpy",
"(",
"mwordsp",
",",
"w",
",",
"wordlen",
"+",
"1",
")",
";",
"mwordsp",
"+=",
"wordlen",
"+",
"1",
";",
"}",
"}"
] | Check each word in the dictionary against the board
Delete words from the machine list that the player has found
Assume both the dictionary and the player's words are already sorted | [
"Check",
"each",
"word",
"in",
"the",
"dictionary",
"against",
"the",
"board",
"Delete",
"words",
"from",
"the",
"machine",
"list",
"that",
"the",
"player",
"has",
"found",
"Assume",
"both",
"the",
"dictionary",
"and",
"the",
"player",
"'",
"s",
"words",
"are",
"already",
"sorted"
] | [
"/*\n\t\t\t * If we've moved on to a word with a different first\n\t\t\t * letter then we can speed things up by skipping all\n\t\t\t * words starting with a letter that doesn't appear in\n\t\t\t * the cube.\n\t\t\t */",
"/*\n\t\t\t * Fall through if the word's first letter appears in\n\t\t\t * the cube (i.e., if we can't skip ahead), otherwise\n\t\t\t * seek to the beginning of words in the dictionary\n\t\t\t * starting with the next letter (alphabetically)\n\t\t\t * appearing in the cube and then read the first word.\n\t\t\t */",
"/* found it */"
] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
33a45781ecf17ed02cbd5b6ea0585d9d06eb4afa | atrens/DragonFlyBSD-src | games/boggle/boggle/bog.c | [
"BSD-3-Clause"
] | C | newgame | void | void
newgame(char *b)
{
unsigned int i;
int p, q;
const char *tmp, **cubes;
int *lm[26];
const char chal_cube[] = "iklmqu"; /* challenge cube */
static const char *cubes4[] = {
"ednosw", "aaciot", "acelrs", "ehinps",
"eefhiy", "elpstu", "acdemp", "gilruw",
"egkluy", "ahmors", "abilty", "adenvz",
"bfiorx", "dknotu", "abjmoq", "egintv"
};
static const char *cubes5[] = {
"aaafrs", "aaeeee", "aafirs", "adennn", "aeeeem",
"aeegmu", "aegmnn", "afirsy", "bjkqxz", "ccnstw",
"ceiilt", "ceilpt", "ceipst", "ddlnor", "dhhlor",
"dhhnot", "dhlnor", "eiiitt", "emottt", "ensssu",
"fiprsy", "gorrvw", "hiprry", "nootuw", "ooottu"
};
cubes = grid == 4 ? cubes4 : cubes5;
if (b == NULL) {
/* Shuffle the cubes using Fisher-Yates (aka Knuth P). */
p = ncubes;
while (--p) {
q = (int)arc4random_uniform(p + 1);
tmp = cubes[p];
cubes[p] = cubes[q];
cubes[q] = tmp;
}
/* Build the board by rolling each cube. */
for (i = 0; i < ncubes; i++)
board[i] = cubes[i][arc4random_uniform(6)];
/*
* For challenge mode, roll chal_cube and replace a random
* cube with its value. Set the high bit to distinguish it.
*/
if (challenge) {
i = arc4random_uniform(ncubes);
board[i] = SETHI(chal_cube[arc4random_uniform(6)]);
}
} else {
for (i = 0; i < ncubes; i++)
board[i] = b[i];
}
board[ncubes] = '\0';
/*
* Set up the map from letter to location(s)
* Each list is terminated by a -1 entry
*/
for (i = 0; i < 26; i++) {
lm[i] = letter_map[i];
*lm[i] = -1;
}
for (i = 0; i < ncubes; i++) {
int j;
j = (int) (SEVENBIT(board[i]) - 'a');
*lm[j] = i;
*(++lm[j]) = -1;
}
if (debug) {
for (i = 0; i < 26; i++) {
int ch, j;
printf("%c:", 'a' + i);
for (j = 0; (ch = letter_map[i][j]) != -1; j++)
printf(" %d", ch);
printf("\n");
}
}
} | /*
* Crank up a new game
* If the argument is non-null then it is assumed to be a legal board spec
* in ascending cube order, oth. make a random board
*/ | Crank up a new game
If the argument is non-null then it is assumed to be a legal board spec
in ascending cube order, oth. make a random board | [
"Crank",
"up",
"a",
"new",
"game",
"If",
"the",
"argument",
"is",
"non",
"-",
"null",
"then",
"it",
"is",
"assumed",
"to",
"be",
"a",
"legal",
"board",
"spec",
"in",
"ascending",
"cube",
"order",
"oth",
".",
"make",
"a",
"random",
"board"
] | void
newgame(char *b)
{
unsigned int i;
int p, q;
const char *tmp, **cubes;
int *lm[26];
const char chal_cube[] = "iklmqu";
static const char *cubes4[] = {
"ednosw", "aaciot", "acelrs", "ehinps",
"eefhiy", "elpstu", "acdemp", "gilruw",
"egkluy", "ahmors", "abilty", "adenvz",
"bfiorx", "dknotu", "abjmoq", "egintv"
};
static const char *cubes5[] = {
"aaafrs", "aaeeee", "aafirs", "adennn", "aeeeem",
"aeegmu", "aegmnn", "afirsy", "bjkqxz", "ccnstw",
"ceiilt", "ceilpt", "ceipst", "ddlnor", "dhhlor",
"dhhnot", "dhlnor", "eiiitt", "emottt", "ensssu",
"fiprsy", "gorrvw", "hiprry", "nootuw", "ooottu"
};
cubes = grid == 4 ? cubes4 : cubes5;
if (b == NULL) {
p = ncubes;
while (--p) {
q = (int)arc4random_uniform(p + 1);
tmp = cubes[p];
cubes[p] = cubes[q];
cubes[q] = tmp;
}
for (i = 0; i < ncubes; i++)
board[i] = cubes[i][arc4random_uniform(6)];
if (challenge) {
i = arc4random_uniform(ncubes);
board[i] = SETHI(chal_cube[arc4random_uniform(6)]);
}
} else {
for (i = 0; i < ncubes; i++)
board[i] = b[i];
}
board[ncubes] = '\0';
for (i = 0; i < 26; i++) {
lm[i] = letter_map[i];
*lm[i] = -1;
}
for (i = 0; i < ncubes; i++) {
int j;
j = (int) (SEVENBIT(board[i]) - 'a');
*lm[j] = i;
*(++lm[j]) = -1;
}
if (debug) {
for (i = 0; i < 26; i++) {
int ch, j;
printf("%c:", 'a' + i);
for (j = 0; (ch = letter_map[i][j]) != -1; j++)
printf(" %d", ch);
printf("\n");
}
}
} | [
"void",
"newgame",
"(",
"char",
"*",
"b",
")",
"{",
"unsigned",
"int",
"i",
";",
"int",
"p",
",",
"q",
";",
"const",
"char",
"*",
"tmp",
",",
"*",
"*",
"cubes",
";",
"int",
"*",
"lm",
"[",
"26",
"]",
";",
"const",
"char",
"chal_cube",
"[",
"]",
"=",
"\"",
"\"",
";",
"static",
"const",
"char",
"*",
"cubes4",
"[",
"]",
"=",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
";",
"static",
"const",
"char",
"*",
"cubes5",
"[",
"]",
"=",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
";",
"cubes",
"=",
"grid",
"==",
"4",
"?",
"cubes4",
":",
"cubes5",
";",
"if",
"(",
"b",
"==",
"NULL",
")",
"{",
"p",
"=",
"ncubes",
";",
"while",
"(",
"--",
"p",
")",
"{",
"q",
"=",
"(",
"int",
")",
"arc4random_uniform",
"(",
"p",
"+",
"1",
")",
";",
"tmp",
"=",
"cubes",
"[",
"p",
"]",
";",
"cubes",
"[",
"p",
"]",
"=",
"cubes",
"[",
"q",
"]",
";",
"cubes",
"[",
"q",
"]",
"=",
"tmp",
";",
"}",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"ncubes",
";",
"i",
"++",
")",
"board",
"[",
"i",
"]",
"=",
"cubes",
"[",
"i",
"]",
"[",
"arc4random_uniform",
"(",
"6",
")",
"]",
";",
"if",
"(",
"challenge",
")",
"{",
"i",
"=",
"arc4random_uniform",
"(",
"ncubes",
")",
";",
"board",
"[",
"i",
"]",
"=",
"SETHI",
"(",
"chal_cube",
"[",
"arc4random_uniform",
"(",
"6",
")",
"]",
")",
";",
"}",
"}",
"else",
"{",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"ncubes",
";",
"i",
"++",
")",
"board",
"[",
"i",
"]",
"=",
"b",
"[",
"i",
"]",
";",
"}",
"board",
"[",
"ncubes",
"]",
"=",
"'",
"\\0",
"'",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"26",
";",
"i",
"++",
")",
"{",
"lm",
"[",
"i",
"]",
"=",
"letter_map",
"[",
"i",
"]",
";",
"*",
"lm",
"[",
"i",
"]",
"=",
"-1",
";",
"}",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"ncubes",
";",
"i",
"++",
")",
"{",
"int",
"j",
";",
"j",
"=",
"(",
"int",
")",
"(",
"SEVENBIT",
"(",
"board",
"[",
"i",
"]",
")",
"-",
"'",
"'",
")",
";",
"*",
"lm",
"[",
"j",
"]",
"=",
"i",
";",
"*",
"(",
"++",
"lm",
"[",
"j",
"]",
")",
"=",
"-1",
";",
"}",
"if",
"(",
"debug",
")",
"{",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"26",
";",
"i",
"++",
")",
"{",
"int",
"ch",
",",
"j",
";",
"printf",
"(",
"\"",
"\"",
",",
"'",
"'",
"+",
"i",
")",
";",
"for",
"(",
"j",
"=",
"0",
";",
"(",
"ch",
"=",
"letter_map",
"[",
"i",
"]",
"[",
"j",
"]",
")",
"!=",
"-1",
";",
"j",
"++",
")",
"printf",
"(",
"\"",
"\"",
",",
"ch",
")",
";",
"printf",
"(",
"\"",
"\\n",
"\"",
")",
";",
"}",
"}",
"}"
] | Crank up a new game
If the argument is non-null then it is assumed to be a legal board spec
in ascending cube order, oth. | [
"Crank",
"up",
"a",
"new",
"game",
"If",
"the",
"argument",
"is",
"non",
"-",
"null",
"then",
"it",
"is",
"assumed",
"to",
"be",
"a",
"legal",
"board",
"spec",
"in",
"ascending",
"cube",
"order",
"oth",
"."
] | [
"/* challenge cube */",
"/* Shuffle the cubes using Fisher-Yates (aka Knuth P). */",
"/* Build the board by rolling each cube. */",
"/*\n\t\t * For challenge mode, roll chal_cube and replace a random\n\t\t * cube with its value. Set the high bit to distinguish it.\n\t\t */",
"/*\n\t * Set up the map from letter to location(s)\n\t * Each list is terminated by a -1 entry\n\t */"
] | [
{
"param": "b",
"type": "char"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "b",
"type": "char",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
33a45781ecf17ed02cbd5b6ea0585d9d06eb4afa | atrens/DragonFlyBSD-src | games/boggle/boggle/bog.c | [
"BSD-3-Clause"
] | C | init | void | static void
init(void)
{
int i;
if (minlength == -1)
minlength = grid - 1;
init_adjacencies();
board = malloc(ncubes + 1);
if (board == NULL)
err(1, NULL);
letter_map = calloc(26, sizeof(int *));
if (letter_map == NULL)
err(1, NULL);
for (i = 0; i < 26; i++) {
letter_map[i] = calloc(ncubes, sizeof(int));
if (letter_map[i] == NULL)
err(1, NULL);
}
pword = calloc(maxpwords, sizeof(char *));
if (pword == NULL)
err(1, NULL);
pwords = malloc(maxpspace);
if (pwords == NULL)
err(1, NULL);
mword = calloc(maxmwords, sizeof(char *));
if (mword == NULL)
err(1, NULL);
mwords = malloc(maxmspace);
if (mwords == NULL)
err(1, NULL);
} | /*
* Allocate and initialize data structures.
*/ | Allocate and initialize data structures. | [
"Allocate",
"and",
"initialize",
"data",
"structures",
"."
] | static void
init(void)
{
int i;
if (minlength == -1)
minlength = grid - 1;
init_adjacencies();
board = malloc(ncubes + 1);
if (board == NULL)
err(1, NULL);
letter_map = calloc(26, sizeof(int *));
if (letter_map == NULL)
err(1, NULL);
for (i = 0; i < 26; i++) {
letter_map[i] = calloc(ncubes, sizeof(int));
if (letter_map[i] == NULL)
err(1, NULL);
}
pword = calloc(maxpwords, sizeof(char *));
if (pword == NULL)
err(1, NULL);
pwords = malloc(maxpspace);
if (pwords == NULL)
err(1, NULL);
mword = calloc(maxmwords, sizeof(char *));
if (mword == NULL)
err(1, NULL);
mwords = malloc(maxmspace);
if (mwords == NULL)
err(1, NULL);
} | [
"static",
"void",
"init",
"(",
"void",
")",
"{",
"int",
"i",
";",
"if",
"(",
"minlength",
"==",
"-1",
")",
"minlength",
"=",
"grid",
"-",
"1",
";",
"init_adjacencies",
"(",
")",
";",
"board",
"=",
"malloc",
"(",
"ncubes",
"+",
"1",
")",
";",
"if",
"(",
"board",
"==",
"NULL",
")",
"err",
"(",
"1",
",",
"NULL",
")",
";",
"letter_map",
"=",
"calloc",
"(",
"26",
",",
"sizeof",
"(",
"int",
"*",
")",
")",
";",
"if",
"(",
"letter_map",
"==",
"NULL",
")",
"err",
"(",
"1",
",",
"NULL",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"26",
";",
"i",
"++",
")",
"{",
"letter_map",
"[",
"i",
"]",
"=",
"calloc",
"(",
"ncubes",
",",
"sizeof",
"(",
"int",
")",
")",
";",
"if",
"(",
"letter_map",
"[",
"i",
"]",
"==",
"NULL",
")",
"err",
"(",
"1",
",",
"NULL",
")",
";",
"}",
"pword",
"=",
"calloc",
"(",
"maxpwords",
",",
"sizeof",
"(",
"char",
"*",
")",
")",
";",
"if",
"(",
"pword",
"==",
"NULL",
")",
"err",
"(",
"1",
",",
"NULL",
")",
";",
"pwords",
"=",
"malloc",
"(",
"maxpspace",
")",
";",
"if",
"(",
"pwords",
"==",
"NULL",
")",
"err",
"(",
"1",
",",
"NULL",
")",
";",
"mword",
"=",
"calloc",
"(",
"maxmwords",
",",
"sizeof",
"(",
"char",
"*",
")",
")",
";",
"if",
"(",
"mword",
"==",
"NULL",
")",
"err",
"(",
"1",
",",
"NULL",
")",
";",
"mwords",
"=",
"malloc",
"(",
"maxmspace",
")",
";",
"if",
"(",
"mwords",
"==",
"NULL",
")",
"err",
"(",
"1",
",",
"NULL",
")",
";",
"}"
] | Allocate and initialize data structures. | [
"Allocate",
"and",
"initialize",
"data",
"structures",
"."
] | [] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
33a45781ecf17ed02cbd5b6ea0585d9d06eb4afa | atrens/DragonFlyBSD-src | games/boggle/boggle/bog.c | [
"BSD-3-Clause"
] | C | init_adjacencies | void | static void
init_adjacencies(void)
{
unsigned int cube;
int row, col, *adj;
adjacency = calloc(ncubes, sizeof(int *));
if (adjacency == NULL)
err(1, NULL);
/*
* Fill in adjacencies. This is an ncubes x ncubes matrix where
* the position X,Y is set to 1 if cubes X and Y are adjacent.
*/
for (cube = 0; cube < ncubes; cube++) {
adj = adjacency[cube] = calloc(ncubes, sizeof(int));
if (adj == NULL)
err(1, NULL);
row = cube / grid;
col = cube % grid;
/* this row */
SET_ADJ(cube);
if (!selfuse)
adj[cube] = 0;
/* prev row */
if (row > 0)
SET_ADJ(cube - grid);
/* next row */
if (row + 1 < grid)
SET_ADJ(cube + grid);
}
} | /*
* Compute adjacency matrix for the grid
*/ | Compute adjacency matrix for the grid | [
"Compute",
"adjacency",
"matrix",
"for",
"the",
"grid"
] | static void
init_adjacencies(void)
{
unsigned int cube;
int row, col, *adj;
adjacency = calloc(ncubes, sizeof(int *));
if (adjacency == NULL)
err(1, NULL);
for (cube = 0; cube < ncubes; cube++) {
adj = adjacency[cube] = calloc(ncubes, sizeof(int));
if (adj == NULL)
err(1, NULL);
row = cube / grid;
col = cube % grid;
SET_ADJ(cube);
if (!selfuse)
adj[cube] = 0;
if (row > 0)
SET_ADJ(cube - grid);
if (row + 1 < grid)
SET_ADJ(cube + grid);
}
} | [
"static",
"void",
"init_adjacencies",
"(",
"void",
")",
"{",
"unsigned",
"int",
"cube",
";",
"int",
"row",
",",
"col",
",",
"*",
"adj",
";",
"adjacency",
"=",
"calloc",
"(",
"ncubes",
",",
"sizeof",
"(",
"int",
"*",
")",
")",
";",
"if",
"(",
"adjacency",
"==",
"NULL",
")",
"err",
"(",
"1",
",",
"NULL",
")",
";",
"for",
"(",
"cube",
"=",
"0",
";",
"cube",
"<",
"ncubes",
";",
"cube",
"++",
")",
"{",
"adj",
"=",
"adjacency",
"[",
"cube",
"]",
"=",
"calloc",
"(",
"ncubes",
",",
"sizeof",
"(",
"int",
")",
")",
";",
"if",
"(",
"adj",
"==",
"NULL",
")",
"err",
"(",
"1",
",",
"NULL",
")",
";",
"row",
"=",
"cube",
"/",
"grid",
";",
"col",
"=",
"cube",
"%",
"grid",
";",
"SET_ADJ",
"(",
"cube",
")",
";",
"if",
"(",
"!",
"selfuse",
")",
"adj",
"[",
"cube",
"]",
"=",
"0",
";",
"if",
"(",
"row",
">",
"0",
")",
"SET_ADJ",
"(",
"cube",
"-",
"grid",
")",
";",
"if",
"(",
"row",
"+",
"1",
"<",
"grid",
")",
"SET_ADJ",
"(",
"cube",
"+",
"grid",
")",
";",
"}",
"}"
] | Compute adjacency matrix for the grid | [
"Compute",
"adjacency",
"matrix",
"for",
"the",
"grid"
] | [
"/*\n\t * Fill in adjacencies. This is an ncubes x ncubes matrix where\n\t * the position X,Y is set to 1 if cubes X and Y are adjacent.\n\t */",
"/* this row */",
"/* prev row */",
"/* next row */"
] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
1e9193d82316b6ce1f8e305ba14d9a4f9b6b94ac | atrens/DragonFlyBSD-src | lib/libc/stdlib/random.c | [
"BSD-3-Clause"
] | C | srandom | void | void
srandom(unsigned long x)
{
int i, lim;
state[0] = (uint32_t)x;
if (rand_type == TYPE_0)
lim = NSHUFF;
else {
for (i = 1; i < rand_deg; i++)
state[i] = good_rand(state[i - 1]);
fptr = &state[rand_sep];
rptr = &state[0];
lim = 10 * rand_deg;
}
for (i = 0; i < lim; i++)
random();
} | /*
* srandom:
*
* Initialize the random number generator based on the given seed. If the
* type is the trivial no-state-information type, just remember the seed.
* Otherwise, initializes state[] based on the given "seed" via a linear
* congruential generator. Then, the pointers are set to known locations
* that are exactly rand_sep places apart. Lastly, it cycles the state
* information a given number of times to get rid of any initial dependencies
* introduced by the L.C.R.N.G. Note that the initialization of randtbl[]
* for default usage relies on values produced by this routine.
*/ | Initialize the random number generator based on the given seed. If the
type is the trivial no-state-information type, just remember the seed.
Otherwise, initializes state[] based on the given "seed" via a linear
congruential generator. Then, the pointers are set to known locations
that are exactly rand_sep places apart. Lastly, it cycles the state
information a given number of times to get rid of any initial dependencies
introduced by the L.C.R.N.G. Note that the initialization of randtbl[]
for default usage relies on values produced by this routine. | [
"Initialize",
"the",
"random",
"number",
"generator",
"based",
"on",
"the",
"given",
"seed",
".",
"If",
"the",
"type",
"is",
"the",
"trivial",
"no",
"-",
"state",
"-",
"information",
"type",
"just",
"remember",
"the",
"seed",
".",
"Otherwise",
"initializes",
"state",
"[]",
"based",
"on",
"the",
"given",
"\"",
"seed",
"\"",
"via",
"a",
"linear",
"congruential",
"generator",
".",
"Then",
"the",
"pointers",
"are",
"set",
"to",
"known",
"locations",
"that",
"are",
"exactly",
"rand_sep",
"places",
"apart",
".",
"Lastly",
"it",
"cycles",
"the",
"state",
"information",
"a",
"given",
"number",
"of",
"times",
"to",
"get",
"rid",
"of",
"any",
"initial",
"dependencies",
"introduced",
"by",
"the",
"L",
".",
"C",
".",
"R",
".",
"N",
".",
"G",
".",
"Note",
"that",
"the",
"initialization",
"of",
"randtbl",
"[]",
"for",
"default",
"usage",
"relies",
"on",
"values",
"produced",
"by",
"this",
"routine",
"."
] | void
srandom(unsigned long x)
{
int i, lim;
state[0] = (uint32_t)x;
if (rand_type == TYPE_0)
lim = NSHUFF;
else {
for (i = 1; i < rand_deg; i++)
state[i] = good_rand(state[i - 1]);
fptr = &state[rand_sep];
rptr = &state[0];
lim = 10 * rand_deg;
}
for (i = 0; i < lim; i++)
random();
} | [
"void",
"srandom",
"(",
"unsigned",
"long",
"x",
")",
"{",
"int",
"i",
",",
"lim",
";",
"state",
"[",
"0",
"]",
"=",
"(",
"uint32_t",
")",
"x",
";",
"if",
"(",
"rand_type",
"==",
"TYPE_0",
")",
"lim",
"=",
"NSHUFF",
";",
"else",
"{",
"for",
"(",
"i",
"=",
"1",
";",
"i",
"<",
"rand_deg",
";",
"i",
"++",
")",
"state",
"[",
"i",
"]",
"=",
"good_rand",
"(",
"state",
"[",
"i",
"-",
"1",
"]",
")",
";",
"fptr",
"=",
"&",
"state",
"[",
"rand_sep",
"]",
";",
"rptr",
"=",
"&",
"state",
"[",
"0",
"]",
";",
"lim",
"=",
"10",
"*",
"rand_deg",
";",
"}",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"lim",
";",
"i",
"++",
")",
"random",
"(",
")",
";",
"}"
] | srandom:
Initialize the random number generator based on the given seed. | [
"srandom",
":",
"Initialize",
"the",
"random",
"number",
"generator",
"based",
"on",
"the",
"given",
"seed",
"."
] | [] | [
{
"param": "x",
"type": "unsigned long"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "x",
"type": "unsigned long",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
1e9193d82316b6ce1f8e305ba14d9a4f9b6b94ac | atrens/DragonFlyBSD-src | lib/libc/stdlib/random.c | [
"BSD-3-Clause"
] | C | srandomdev | void | void
srandomdev(void)
{
size_t len;
size_t n;
int fd;
if (rand_type == TYPE_0)
len = sizeof state[0];
else
len = rand_deg * sizeof state[0];
/*
* Standard
*/
fd = _open("/dev/random", O_RDONLY|O_CLOEXEC, 0);
if (fd >= 0) {
n = _read(fd, (void *)state, len);
_close(fd);
if ((ssize_t)n < 0)
n = 0;
}
/*
* Back-off incase chroot has no access to /dev/random
*/
n = n & ~15;
if (n < len) {
size_t r = len - n;
if (sysctlbyname("kern.random", (char *)state + n,
&r, NULL, 0) == 0) {
n += r;
}
}
/*
* Pray
*
* NOTE: 'random' data on the stack is not random, don't try to
* access it.
*/
n = n & ~15;
if (n < len) {
struct timeval tv;
gettimeofday(&tv, NULL);
srandom((getpid() << 16) ^ tv.tv_sec ^ tv.tv_usec);
return;
}
if (rand_type != TYPE_0) {
fptr = &state[rand_sep];
rptr = &state[0];
}
} | /*
* srandomdev:
*
* Many programs choose the seed value in a totally predictable manner.
* This often causes problems. We seed the generator using the much more
* secure random(4) interface. Note that this particular seeding
* procedure can generate states which are impossible to reproduce by
* calling srandom() with any value, since the succeeding terms in the
* state buffer are no longer derived from the LC algorithm applied to
* a fixed seed.
*/ | Many programs choose the seed value in a totally predictable manner.
This often causes problems. We seed the generator using the much more
secure random(4) interface. Note that this particular seeding
procedure can generate states which are impossible to reproduce by
calling srandom() with any value, since the succeeding terms in the
state buffer are no longer derived from the LC algorithm applied to
a fixed seed. | [
"Many",
"programs",
"choose",
"the",
"seed",
"value",
"in",
"a",
"totally",
"predictable",
"manner",
".",
"This",
"often",
"causes",
"problems",
".",
"We",
"seed",
"the",
"generator",
"using",
"the",
"much",
"more",
"secure",
"random",
"(",
"4",
")",
"interface",
".",
"Note",
"that",
"this",
"particular",
"seeding",
"procedure",
"can",
"generate",
"states",
"which",
"are",
"impossible",
"to",
"reproduce",
"by",
"calling",
"srandom",
"()",
"with",
"any",
"value",
"since",
"the",
"succeeding",
"terms",
"in",
"the",
"state",
"buffer",
"are",
"no",
"longer",
"derived",
"from",
"the",
"LC",
"algorithm",
"applied",
"to",
"a",
"fixed",
"seed",
"."
] | void
srandomdev(void)
{
size_t len;
size_t n;
int fd;
if (rand_type == TYPE_0)
len = sizeof state[0];
else
len = rand_deg * sizeof state[0];
fd = _open("/dev/random", O_RDONLY|O_CLOEXEC, 0);
if (fd >= 0) {
n = _read(fd, (void *)state, len);
_close(fd);
if ((ssize_t)n < 0)
n = 0;
}
n = n & ~15;
if (n < len) {
size_t r = len - n;
if (sysctlbyname("kern.random", (char *)state + n,
&r, NULL, 0) == 0) {
n += r;
}
}
n = n & ~15;
if (n < len) {
struct timeval tv;
gettimeofday(&tv, NULL);
srandom((getpid() << 16) ^ tv.tv_sec ^ tv.tv_usec);
return;
}
if (rand_type != TYPE_0) {
fptr = &state[rand_sep];
rptr = &state[0];
}
} | [
"void",
"srandomdev",
"(",
"void",
")",
"{",
"size_t",
"len",
";",
"size_t",
"n",
";",
"int",
"fd",
";",
"if",
"(",
"rand_type",
"==",
"TYPE_0",
")",
"len",
"=",
"sizeof",
"state",
"[",
"0",
"]",
";",
"else",
"len",
"=",
"rand_deg",
"*",
"sizeof",
"state",
"[",
"0",
"]",
";",
"fd",
"=",
"_open",
"(",
"\"",
"\"",
",",
"O_RDONLY",
"|",
"O_CLOEXEC",
",",
"0",
")",
";",
"if",
"(",
"fd",
">=",
"0",
")",
"{",
"n",
"=",
"_read",
"(",
"fd",
",",
"(",
"void",
"*",
")",
"state",
",",
"len",
")",
";",
"_close",
"(",
"fd",
")",
";",
"if",
"(",
"(",
"ssize_t",
")",
"n",
"<",
"0",
")",
"n",
"=",
"0",
";",
"}",
"n",
"=",
"n",
"&",
"~",
"15",
";",
"if",
"(",
"n",
"<",
"len",
")",
"{",
"size_t",
"r",
"=",
"len",
"-",
"n",
";",
"if",
"(",
"sysctlbyname",
"(",
"\"",
"\"",
",",
"(",
"char",
"*",
")",
"state",
"+",
"n",
",",
"&",
"r",
",",
"NULL",
",",
"0",
")",
"==",
"0",
")",
"{",
"n",
"+=",
"r",
";",
"}",
"}",
"n",
"=",
"n",
"&",
"~",
"15",
";",
"if",
"(",
"n",
"<",
"len",
")",
"{",
"struct",
"timeval",
"tv",
";",
"gettimeofday",
"(",
"&",
"tv",
",",
"NULL",
")",
";",
"srandom",
"(",
"(",
"getpid",
"(",
")",
"<<",
"16",
")",
"^",
"tv",
".",
"tv_sec",
"^",
"tv",
".",
"tv_usec",
")",
";",
"return",
";",
"}",
"if",
"(",
"rand_type",
"!=",
"TYPE_0",
")",
"{",
"fptr",
"=",
"&",
"state",
"[",
"rand_sep",
"]",
";",
"rptr",
"=",
"&",
"state",
"[",
"0",
"]",
";",
"}",
"}"
] | srandomdev:
Many programs choose the seed value in a totally predictable manner. | [
"srandomdev",
":",
"Many",
"programs",
"choose",
"the",
"seed",
"value",
"in",
"a",
"totally",
"predictable",
"manner",
"."
] | [
"/*\n\t * Standard\n\t */",
"/*\n\t * Back-off incase chroot has no access to /dev/random\n\t */",
"/*\n\t * Pray\n\t *\n\t * NOTE: 'random' data on the stack is not random, don't try to\n\t *\t access it.\n\t */"
] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
1e9193d82316b6ce1f8e305ba14d9a4f9b6b94ac | atrens/DragonFlyBSD-src | lib/libc/stdlib/random.c | [
"BSD-3-Clause"
] | C | initstate | char | char *
initstate(unsigned long seed, char *arg_state, long n)
{
char *ostate = (char *)(&state[-1]);
uint32_t *int_arg_state = (uint32_t *)arg_state;
if (rand_type == TYPE_0)
state[-1] = rand_type;
else
state[-1] = MAX_TYPES * (rptr - state) + rand_type;
if (n < BREAK_0) {
fprintf(stderr,
"random: not enough state (%ld bytes); ignored.\n", n);
return(0);
}
if (n < BREAK_1) {
rand_type = TYPE_0;
rand_deg = DEG_0;
rand_sep = SEP_0;
} else if (n < BREAK_2) {
rand_type = TYPE_1;
rand_deg = DEG_1;
rand_sep = SEP_1;
} else if (n < BREAK_3) {
rand_type = TYPE_2;
rand_deg = DEG_2;
rand_sep = SEP_2;
} else if (n < BREAK_4) {
rand_type = TYPE_3;
rand_deg = DEG_3;
rand_sep = SEP_3;
} else {
rand_type = TYPE_4;
rand_deg = DEG_4;
rand_sep = SEP_4;
}
state = int_arg_state + 1; /* first location */
end_ptr = &state[rand_deg]; /* must set end_ptr before srandom */
srandom(seed);
if (rand_type == TYPE_0)
int_arg_state[0] = rand_type;
else
int_arg_state[0] = MAX_TYPES * (rptr - state) + rand_type;
return(ostate);
} | /*
* initstate:
*
* Initialize the state information in the given array of n bytes for future
* random number generation. Based on the number of bytes we are given, and
* the break values for the different R.N.G.'s, we choose the best (largest)
* one we can and set things up for it. srandom() is then called to
* initialize the state information.
*
* Note that on return from srandom(), we set state[-1] to be the type
* multiplexed with the current value of the rear pointer; this is so
* successive calls to initstate() won't lose this information and will be
* able to restart with setstate().
*
* Note: the first thing we do is save the current state, if any, just like
* setstate() so that it doesn't matter when initstate is called.
*
* Parameters:
* seed: seed for R.N.G.
* arg_state: pointer to state array
* n: # bytes of state info
*
* Returns a pointer to the old state.
*
* Note: The Sparc platform requires that arg_state begin on an int
* word boundary; otherwise a bus error will occur. Even so, lint will
* complain about mis-alignment, but you should disregard these messages.
*/ | Initialize the state information in the given array of n bytes for future
random number generation. Based on the number of bytes we are given, and
the break values for the different R.N.G.'s, we choose the best (largest)
one we can and set things up for it. srandom() is then called to
initialize the state information.
Note that on return from srandom(), we set state[-1] to be the type
multiplexed with the current value of the rear pointer; this is so
successive calls to initstate() won't lose this information and will be
able to restart with setstate().
the first thing we do is save the current state, if any, just like
setstate() so that it doesn't matter when initstate is called.
Returns a pointer to the old state.
The Sparc platform requires that arg_state begin on an int
word boundary; otherwise a bus error will occur. Even so, lint will
complain about mis-alignment, but you should disregard these messages. | [
"Initialize",
"the",
"state",
"information",
"in",
"the",
"given",
"array",
"of",
"n",
"bytes",
"for",
"future",
"random",
"number",
"generation",
".",
"Based",
"on",
"the",
"number",
"of",
"bytes",
"we",
"are",
"given",
"and",
"the",
"break",
"values",
"for",
"the",
"different",
"R",
".",
"N",
".",
"G",
".",
"'",
"s",
"we",
"choose",
"the",
"best",
"(",
"largest",
")",
"one",
"we",
"can",
"and",
"set",
"things",
"up",
"for",
"it",
".",
"srandom",
"()",
"is",
"then",
"called",
"to",
"initialize",
"the",
"state",
"information",
".",
"Note",
"that",
"on",
"return",
"from",
"srandom",
"()",
"we",
"set",
"state",
"[",
"-",
"1",
"]",
"to",
"be",
"the",
"type",
"multiplexed",
"with",
"the",
"current",
"value",
"of",
"the",
"rear",
"pointer",
";",
"this",
"is",
"so",
"successive",
"calls",
"to",
"initstate",
"()",
"won",
"'",
"t",
"lose",
"this",
"information",
"and",
"will",
"be",
"able",
"to",
"restart",
"with",
"setstate",
"()",
".",
"the",
"first",
"thing",
"we",
"do",
"is",
"save",
"the",
"current",
"state",
"if",
"any",
"just",
"like",
"setstate",
"()",
"so",
"that",
"it",
"doesn",
"'",
"t",
"matter",
"when",
"initstate",
"is",
"called",
".",
"Returns",
"a",
"pointer",
"to",
"the",
"old",
"state",
".",
"The",
"Sparc",
"platform",
"requires",
"that",
"arg_state",
"begin",
"on",
"an",
"int",
"word",
"boundary",
";",
"otherwise",
"a",
"bus",
"error",
"will",
"occur",
".",
"Even",
"so",
"lint",
"will",
"complain",
"about",
"mis",
"-",
"alignment",
"but",
"you",
"should",
"disregard",
"these",
"messages",
"."
] | char *
initstate(unsigned long seed, char *arg_state, long n)
{
char *ostate = (char *)(&state[-1]);
uint32_t *int_arg_state = (uint32_t *)arg_state;
if (rand_type == TYPE_0)
state[-1] = rand_type;
else
state[-1] = MAX_TYPES * (rptr - state) + rand_type;
if (n < BREAK_0) {
fprintf(stderr,
"random: not enough state (%ld bytes); ignored.\n", n);
return(0);
}
if (n < BREAK_1) {
rand_type = TYPE_0;
rand_deg = DEG_0;
rand_sep = SEP_0;
} else if (n < BREAK_2) {
rand_type = TYPE_1;
rand_deg = DEG_1;
rand_sep = SEP_1;
} else if (n < BREAK_3) {
rand_type = TYPE_2;
rand_deg = DEG_2;
rand_sep = SEP_2;
} else if (n < BREAK_4) {
rand_type = TYPE_3;
rand_deg = DEG_3;
rand_sep = SEP_3;
} else {
rand_type = TYPE_4;
rand_deg = DEG_4;
rand_sep = SEP_4;
}
state = int_arg_state + 1;
end_ptr = &state[rand_deg];
srandom(seed);
if (rand_type == TYPE_0)
int_arg_state[0] = rand_type;
else
int_arg_state[0] = MAX_TYPES * (rptr - state) + rand_type;
return(ostate);
} | [
"char",
"*",
"initstate",
"(",
"unsigned",
"long",
"seed",
",",
"char",
"*",
"arg_state",
",",
"long",
"n",
")",
"{",
"char",
"*",
"ostate",
"=",
"(",
"char",
"*",
")",
"(",
"&",
"state",
"[",
"-1",
"]",
")",
";",
"uint32_t",
"*",
"int_arg_state",
"=",
"(",
"uint32_t",
"*",
")",
"arg_state",
";",
"if",
"(",
"rand_type",
"==",
"TYPE_0",
")",
"state",
"[",
"-1",
"]",
"=",
"rand_type",
";",
"else",
"state",
"[",
"-1",
"]",
"=",
"MAX_TYPES",
"*",
"(",
"rptr",
"-",
"state",
")",
"+",
"rand_type",
";",
"if",
"(",
"n",
"<",
"BREAK_0",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\"",
"\\n",
"\"",
",",
"n",
")",
";",
"return",
"(",
"0",
")",
";",
"}",
"if",
"(",
"n",
"<",
"BREAK_1",
")",
"{",
"rand_type",
"=",
"TYPE_0",
";",
"rand_deg",
"=",
"DEG_0",
";",
"rand_sep",
"=",
"SEP_0",
";",
"}",
"else",
"if",
"(",
"n",
"<",
"BREAK_2",
")",
"{",
"rand_type",
"=",
"TYPE_1",
";",
"rand_deg",
"=",
"DEG_1",
";",
"rand_sep",
"=",
"SEP_1",
";",
"}",
"else",
"if",
"(",
"n",
"<",
"BREAK_3",
")",
"{",
"rand_type",
"=",
"TYPE_2",
";",
"rand_deg",
"=",
"DEG_2",
";",
"rand_sep",
"=",
"SEP_2",
";",
"}",
"else",
"if",
"(",
"n",
"<",
"BREAK_4",
")",
"{",
"rand_type",
"=",
"TYPE_3",
";",
"rand_deg",
"=",
"DEG_3",
";",
"rand_sep",
"=",
"SEP_3",
";",
"}",
"else",
"{",
"rand_type",
"=",
"TYPE_4",
";",
"rand_deg",
"=",
"DEG_4",
";",
"rand_sep",
"=",
"SEP_4",
";",
"}",
"state",
"=",
"int_arg_state",
"+",
"1",
";",
"end_ptr",
"=",
"&",
"state",
"[",
"rand_deg",
"]",
";",
"srandom",
"(",
"seed",
")",
";",
"if",
"(",
"rand_type",
"==",
"TYPE_0",
")",
"int_arg_state",
"[",
"0",
"]",
"=",
"rand_type",
";",
"else",
"int_arg_state",
"[",
"0",
"]",
"=",
"MAX_TYPES",
"*",
"(",
"rptr",
"-",
"state",
")",
"+",
"rand_type",
";",
"return",
"(",
"ostate",
")",
";",
"}"
] | initstate:
Initialize the state information in the given array of n bytes for future
random number generation. | [
"initstate",
":",
"Initialize",
"the",
"state",
"information",
"in",
"the",
"given",
"array",
"of",
"n",
"bytes",
"for",
"future",
"random",
"number",
"generation",
"."
] | [
"/* first location */",
"/* must set end_ptr before srandom */"
] | [
{
"param": "seed",
"type": "unsigned long"
},
{
"param": "arg_state",
"type": "char"
},
{
"param": "n",
"type": "long"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "seed",
"type": "unsigned long",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "arg_state",
"type": "char",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "n",
"type": "long",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
1e9193d82316b6ce1f8e305ba14d9a4f9b6b94ac | atrens/DragonFlyBSD-src | lib/libc/stdlib/random.c | [
"BSD-3-Clause"
] | C | random | null | long
random(void)
{
uint32_t i;
uint32_t *f, *r;
if (rand_type == TYPE_0) {
i = state[0];
state[0] = i = (good_rand(i)) & 0x7fffffff;
} else {
/*
* Use local variables rather than static variables for speed.
*/
f = fptr; r = rptr;
*f += *r;
/* chucking least random bit */
i = (*f >> 1) & 0x7fffffff;
if (++f >= end_ptr) {
f = state;
++r;
}
else if (++r >= end_ptr) {
r = state;
}
fptr = f; rptr = r;
}
return((long)i);
} | /*
* random:
*
* If we are using the trivial TYPE_0 R.N.G., just do the old linear
* congruential bit. Otherwise, we do our fancy trinomial stuff, which is
* the same in all the other cases due to all the global variables that have
* been set up. The basic operation is to add the number at the rear pointer
* into the one at the front pointer. Then both pointers are advanced to
* the next location cyclically in the table. The value returned is the sum
* generated, reduced to 31 bits by throwing away the "least random" low bit.
*
* Note: the code takes advantage of the fact that both the front and
* rear pointers can't wrap on the same call by not testing the rear
* pointer if the front one has wrapped.
*
* Returns a 31-bit random number.
*/ | If we are using the trivial TYPE_0 R.N.G., just do the old linear
congruential bit. Otherwise, we do our fancy trinomial stuff, which is
the same in all the other cases due to all the global variables that have
been set up. The basic operation is to add the number at the rear pointer
into the one at the front pointer. Then both pointers are advanced to
the next location cyclically in the table. The value returned is the sum
generated, reduced to 31 bits by throwing away the "least random" low bit.
the code takes advantage of the fact that both the front and
rear pointers can't wrap on the same call by not testing the rear
pointer if the front one has wrapped.
Returns a 31-bit random number. | [
"If",
"we",
"are",
"using",
"the",
"trivial",
"TYPE_0",
"R",
".",
"N",
".",
"G",
".",
"just",
"do",
"the",
"old",
"linear",
"congruential",
"bit",
".",
"Otherwise",
"we",
"do",
"our",
"fancy",
"trinomial",
"stuff",
"which",
"is",
"the",
"same",
"in",
"all",
"the",
"other",
"cases",
"due",
"to",
"all",
"the",
"global",
"variables",
"that",
"have",
"been",
"set",
"up",
".",
"The",
"basic",
"operation",
"is",
"to",
"add",
"the",
"number",
"at",
"the",
"rear",
"pointer",
"into",
"the",
"one",
"at",
"the",
"front",
"pointer",
".",
"Then",
"both",
"pointers",
"are",
"advanced",
"to",
"the",
"next",
"location",
"cyclically",
"in",
"the",
"table",
".",
"The",
"value",
"returned",
"is",
"the",
"sum",
"generated",
"reduced",
"to",
"31",
"bits",
"by",
"throwing",
"away",
"the",
"\"",
"least",
"random",
"\"",
"low",
"bit",
".",
"the",
"code",
"takes",
"advantage",
"of",
"the",
"fact",
"that",
"both",
"the",
"front",
"and",
"rear",
"pointers",
"can",
"'",
"t",
"wrap",
"on",
"the",
"same",
"call",
"by",
"not",
"testing",
"the",
"rear",
"pointer",
"if",
"the",
"front",
"one",
"has",
"wrapped",
".",
"Returns",
"a",
"31",
"-",
"bit",
"random",
"number",
"."
] | long
random(void)
{
uint32_t i;
uint32_t *f, *r;
if (rand_type == TYPE_0) {
i = state[0];
state[0] = i = (good_rand(i)) & 0x7fffffff;
} else {
f = fptr; r = rptr;
*f += *r;
i = (*f >> 1) & 0x7fffffff;
if (++f >= end_ptr) {
f = state;
++r;
}
else if (++r >= end_ptr) {
r = state;
}
fptr = f; rptr = r;
}
return((long)i);
} | [
"long",
"random",
"(",
"void",
")",
"{",
"uint32_t",
"i",
";",
"uint32_t",
"*",
"f",
",",
"*",
"r",
";",
"if",
"(",
"rand_type",
"==",
"TYPE_0",
")",
"{",
"i",
"=",
"state",
"[",
"0",
"]",
";",
"state",
"[",
"0",
"]",
"=",
"i",
"=",
"(",
"good_rand",
"(",
"i",
")",
")",
"&",
"0x7fffffff",
";",
"}",
"else",
"{",
"f",
"=",
"fptr",
";",
"r",
"=",
"rptr",
";",
"*",
"f",
"+=",
"*",
"r",
";",
"i",
"=",
"(",
"*",
"f",
">>",
"1",
")",
"&",
"0x7fffffff",
";",
"if",
"(",
"++",
"f",
">=",
"end_ptr",
")",
"{",
"f",
"=",
"state",
";",
"++",
"r",
";",
"}",
"else",
"if",
"(",
"++",
"r",
">=",
"end_ptr",
")",
"{",
"r",
"=",
"state",
";",
"}",
"fptr",
"=",
"f",
";",
"rptr",
"=",
"r",
";",
"}",
"return",
"(",
"(",
"long",
")",
"i",
")",
";",
"}"
] | random:
If we are using the trivial TYPE_0 R.N.G., just do the old linear
congruential bit. | [
"random",
":",
"If",
"we",
"are",
"using",
"the",
"trivial",
"TYPE_0",
"R",
".",
"N",
".",
"G",
".",
"just",
"do",
"the",
"old",
"linear",
"congruential",
"bit",
"."
] | [
"/*\n\t\t * Use local variables rather than static variables for speed.\n\t\t */",
"/* chucking least random bit */"
] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
a772e09b8568cf55838f8697508b51befe07a6b5 | atrens/DragonFlyBSD-src | sbin/routed/if.c | [
"BSD-3-Clause"
] | C | if_link | void | void
if_link(struct interface *ifp)
{
struct interface **hifp;
ifp->int_prev = &ifnet;
ifp->int_next = ifnet;
if (ifnet != NULL)
ifnet->int_prev = &ifp->int_next;
ifnet = ifp;
hifp = AHASH(ifp->int_addr);
ifp->int_ahash_prev = hifp;
if ((ifp->int_ahash = *hifp) != NULL)
(*hifp)->int_ahash_prev = &ifp->int_ahash;
*hifp = ifp;
if (ifp->int_if_flags & IFF_BROADCAST) {
hifp = BHASH(ifp->int_brdaddr);
ifp->int_bhash_prev = hifp;
if ((ifp->int_bhash = *hifp) != NULL)
(*hifp)->int_bhash_prev = &ifp->int_bhash;
*hifp = ifp;
}
if (ifp->int_state & IS_REMOTE) {
ifp->int_rlink_prev = &remote_if;
ifp->int_rlink = remote_if;
if (remote_if != NULL)
remote_if->int_rlink_prev = &ifp->int_rlink;
remote_if = ifp;
}
hifp = nhash(ifp->int_name);
if (ifp->int_state & IS_ALIAS) {
/* put aliases on the end of the hash chain */
while (*hifp != NULL)
hifp = &(*hifp)->int_nhash;
}
ifp->int_nhash_prev = hifp;
if ((ifp->int_nhash = *hifp) != NULL)
(*hifp)->int_nhash_prev = &ifp->int_nhash;
*hifp = ifp;
} | /* Link a new interface into the lists and hash tables.
*/ | Link a new interface into the lists and hash tables. | [
"Link",
"a",
"new",
"interface",
"into",
"the",
"lists",
"and",
"hash",
"tables",
"."
] | void
if_link(struct interface *ifp)
{
struct interface **hifp;
ifp->int_prev = &ifnet;
ifp->int_next = ifnet;
if (ifnet != NULL)
ifnet->int_prev = &ifp->int_next;
ifnet = ifp;
hifp = AHASH(ifp->int_addr);
ifp->int_ahash_prev = hifp;
if ((ifp->int_ahash = *hifp) != NULL)
(*hifp)->int_ahash_prev = &ifp->int_ahash;
*hifp = ifp;
if (ifp->int_if_flags & IFF_BROADCAST) {
hifp = BHASH(ifp->int_brdaddr);
ifp->int_bhash_prev = hifp;
if ((ifp->int_bhash = *hifp) != NULL)
(*hifp)->int_bhash_prev = &ifp->int_bhash;
*hifp = ifp;
}
if (ifp->int_state & IS_REMOTE) {
ifp->int_rlink_prev = &remote_if;
ifp->int_rlink = remote_if;
if (remote_if != NULL)
remote_if->int_rlink_prev = &ifp->int_rlink;
remote_if = ifp;
}
hifp = nhash(ifp->int_name);
if (ifp->int_state & IS_ALIAS) {
while (*hifp != NULL)
hifp = &(*hifp)->int_nhash;
}
ifp->int_nhash_prev = hifp;
if ((ifp->int_nhash = *hifp) != NULL)
(*hifp)->int_nhash_prev = &ifp->int_nhash;
*hifp = ifp;
} | [
"void",
"if_link",
"(",
"struct",
"interface",
"*",
"ifp",
")",
"{",
"struct",
"interface",
"*",
"*",
"hifp",
";",
"ifp",
"->",
"int_prev",
"=",
"&",
"ifnet",
";",
"ifp",
"->",
"int_next",
"=",
"ifnet",
";",
"if",
"(",
"ifnet",
"!=",
"NULL",
")",
"ifnet",
"->",
"int_prev",
"=",
"&",
"ifp",
"->",
"int_next",
";",
"ifnet",
"=",
"ifp",
";",
"hifp",
"=",
"AHASH",
"(",
"ifp",
"->",
"int_addr",
")",
";",
"ifp",
"->",
"int_ahash_prev",
"=",
"hifp",
";",
"if",
"(",
"(",
"ifp",
"->",
"int_ahash",
"=",
"*",
"hifp",
")",
"!=",
"NULL",
")",
"(",
"*",
"hifp",
")",
"->",
"int_ahash_prev",
"=",
"&",
"ifp",
"->",
"int_ahash",
";",
"*",
"hifp",
"=",
"ifp",
";",
"if",
"(",
"ifp",
"->",
"int_if_flags",
"&",
"IFF_BROADCAST",
")",
"{",
"hifp",
"=",
"BHASH",
"(",
"ifp",
"->",
"int_brdaddr",
")",
";",
"ifp",
"->",
"int_bhash_prev",
"=",
"hifp",
";",
"if",
"(",
"(",
"ifp",
"->",
"int_bhash",
"=",
"*",
"hifp",
")",
"!=",
"NULL",
")",
"(",
"*",
"hifp",
")",
"->",
"int_bhash_prev",
"=",
"&",
"ifp",
"->",
"int_bhash",
";",
"*",
"hifp",
"=",
"ifp",
";",
"}",
"if",
"(",
"ifp",
"->",
"int_state",
"&",
"IS_REMOTE",
")",
"{",
"ifp",
"->",
"int_rlink_prev",
"=",
"&",
"remote_if",
";",
"ifp",
"->",
"int_rlink",
"=",
"remote_if",
";",
"if",
"(",
"remote_if",
"!=",
"NULL",
")",
"remote_if",
"->",
"int_rlink_prev",
"=",
"&",
"ifp",
"->",
"int_rlink",
";",
"remote_if",
"=",
"ifp",
";",
"}",
"hifp",
"=",
"nhash",
"(",
"ifp",
"->",
"int_name",
")",
";",
"if",
"(",
"ifp",
"->",
"int_state",
"&",
"IS_ALIAS",
")",
"{",
"while",
"(",
"*",
"hifp",
"!=",
"NULL",
")",
"hifp",
"=",
"&",
"(",
"*",
"hifp",
")",
"->",
"int_nhash",
";",
"}",
"ifp",
"->",
"int_nhash_prev",
"=",
"hifp",
";",
"if",
"(",
"(",
"ifp",
"->",
"int_nhash",
"=",
"*",
"hifp",
")",
"!=",
"NULL",
")",
"(",
"*",
"hifp",
")",
"->",
"int_nhash_prev",
"=",
"&",
"ifp",
"->",
"int_nhash",
";",
"*",
"hifp",
"=",
"ifp",
";",
"}"
] | Link a new interface into the lists and hash tables. | [
"Link",
"a",
"new",
"interface",
"into",
"the",
"lists",
"and",
"hash",
"tables",
"."
] | [
"/* put aliases on the end of the hash chain */"
] | [
{
"param": "ifp",
"type": "struct interface"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "ifp",
"type": "struct interface",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
a772e09b8568cf55838f8697508b51befe07a6b5 | atrens/DragonFlyBSD-src | sbin/routed/if.c | [
"BSD-3-Clause"
] | C | ifwithaddr | null | struct interface *
ifwithaddr(naddr addr,
int bcast, /* notice IFF_BROADCAST address */
int remote) /* include IS_REMOTE interfaces */
{
struct interface *ifp, *possible = NULL;
remote = (remote == 0) ? IS_REMOTE : 0;
for (ifp = *AHASH(addr); ifp; ifp = ifp->int_ahash) {
if (ifp->int_addr != addr)
continue;
if ((ifp->int_state & remote) != 0)
continue;
if ((ifp->int_state & (IS_BROKE | IS_PASSIVE)) == 0)
return ifp;
possible = ifp;
}
if (possible || !bcast)
return possible;
for (ifp = *BHASH(addr); ifp; ifp = ifp->int_bhash) {
if (ifp->int_brdaddr != addr)
continue;
if ((ifp->int_state & remote) != 0)
continue;
if ((ifp->int_state & (IS_BROKE | IS_PASSIVE)) == 0)
return ifp;
possible = ifp;
}
return possible;
} | /* Find the interface with an address
*/ | Find the interface with an address | [
"Find",
"the",
"interface",
"with",
"an",
"address"
] | struct interface *
ifwithaddr(naddr addr,
int bcast,
int remote)
{
struct interface *ifp, *possible = NULL;
remote = (remote == 0) ? IS_REMOTE : 0;
for (ifp = *AHASH(addr); ifp; ifp = ifp->int_ahash) {
if (ifp->int_addr != addr)
continue;
if ((ifp->int_state & remote) != 0)
continue;
if ((ifp->int_state & (IS_BROKE | IS_PASSIVE)) == 0)
return ifp;
possible = ifp;
}
if (possible || !bcast)
return possible;
for (ifp = *BHASH(addr); ifp; ifp = ifp->int_bhash) {
if (ifp->int_brdaddr != addr)
continue;
if ((ifp->int_state & remote) != 0)
continue;
if ((ifp->int_state & (IS_BROKE | IS_PASSIVE)) == 0)
return ifp;
possible = ifp;
}
return possible;
} | [
"struct",
"interface",
"*",
"ifwithaddr",
"(",
"naddr",
"addr",
",",
"int",
"bcast",
",",
"int",
"remote",
")",
"{",
"struct",
"interface",
"*",
"ifp",
",",
"*",
"possible",
"=",
"NULL",
";",
"remote",
"=",
"(",
"remote",
"==",
"0",
")",
"?",
"IS_REMOTE",
":",
"0",
";",
"for",
"(",
"ifp",
"=",
"*",
"AHASH",
"(",
"addr",
")",
";",
"ifp",
";",
"ifp",
"=",
"ifp",
"->",
"int_ahash",
")",
"{",
"if",
"(",
"ifp",
"->",
"int_addr",
"!=",
"addr",
")",
"continue",
";",
"if",
"(",
"(",
"ifp",
"->",
"int_state",
"&",
"remote",
")",
"!=",
"0",
")",
"continue",
";",
"if",
"(",
"(",
"ifp",
"->",
"int_state",
"&",
"(",
"IS_BROKE",
"|",
"IS_PASSIVE",
")",
")",
"==",
"0",
")",
"return",
"ifp",
";",
"possible",
"=",
"ifp",
";",
"}",
"if",
"(",
"possible",
"||",
"!",
"bcast",
")",
"return",
"possible",
";",
"for",
"(",
"ifp",
"=",
"*",
"BHASH",
"(",
"addr",
")",
";",
"ifp",
";",
"ifp",
"=",
"ifp",
"->",
"int_bhash",
")",
"{",
"if",
"(",
"ifp",
"->",
"int_brdaddr",
"!=",
"addr",
")",
"continue",
";",
"if",
"(",
"(",
"ifp",
"->",
"int_state",
"&",
"remote",
")",
"!=",
"0",
")",
"continue",
";",
"if",
"(",
"(",
"ifp",
"->",
"int_state",
"&",
"(",
"IS_BROKE",
"|",
"IS_PASSIVE",
")",
")",
"==",
"0",
")",
"return",
"ifp",
";",
"possible",
"=",
"ifp",
";",
"}",
"return",
"possible",
";",
"}"
] | Find the interface with an address | [
"Find",
"the",
"interface",
"with",
"an",
"address"
] | [
"/* notice IFF_BROADCAST address */",
"/* include IS_REMOTE interfaces */"
] | [
{
"param": "addr",
"type": "naddr"
},
{
"param": "bcast",
"type": "int"
},
{
"param": "remote",
"type": "int"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "addr",
"type": "naddr",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "bcast",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "remote",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
a772e09b8568cf55838f8697508b51befe07a6b5 | atrens/DragonFlyBSD-src | sbin/routed/if.c | [
"BSD-3-Clause"
] | C | ifwithname | null | struct interface *
ifwithname(char *name, /* "ec0" or whatever */
naddr addr) /* 0 or network address */
{
struct interface *ifp;
for (;;) {
for (ifp = *nhash(name); ifp != NULL; ifp = ifp->int_nhash) {
/* If the network address is not specified,
* ignore any alias interfaces. Otherwise, look
* for the interface with the target name and address.
*/
if (!strcmp(ifp->int_name, name)
&& ((addr == 0 && !(ifp->int_state & IS_ALIAS))
|| (ifp->int_addr == addr)))
return ifp;
}
/* If there is no known interface, maybe there is a
* new interface. So just once look for new interfaces.
*/
if (IF_RESCAN_DELAY())
return 0;
ifinit();
}
} | /* find the interface with a name
*/ | find the interface with a name | [
"find",
"the",
"interface",
"with",
"a",
"name"
] | struct interface *
ifwithname(char *name,
naddr addr)
{
struct interface *ifp;
for (;;) {
for (ifp = *nhash(name); ifp != NULL; ifp = ifp->int_nhash) {
if (!strcmp(ifp->int_name, name)
&& ((addr == 0 && !(ifp->int_state & IS_ALIAS))
|| (ifp->int_addr == addr)))
return ifp;
}
if (IF_RESCAN_DELAY())
return 0;
ifinit();
}
} | [
"struct",
"interface",
"*",
"ifwithname",
"(",
"char",
"*",
"name",
",",
"naddr",
"addr",
")",
"{",
"struct",
"interface",
"*",
"ifp",
";",
"for",
"(",
";",
";",
")",
"{",
"for",
"(",
"ifp",
"=",
"*",
"nhash",
"(",
"name",
")",
";",
"ifp",
"!=",
"NULL",
";",
"ifp",
"=",
"ifp",
"->",
"int_nhash",
")",
"{",
"if",
"(",
"!",
"strcmp",
"(",
"ifp",
"->",
"int_name",
",",
"name",
")",
"&&",
"(",
"(",
"addr",
"==",
"0",
"&&",
"!",
"(",
"ifp",
"->",
"int_state",
"&",
"IS_ALIAS",
")",
")",
"||",
"(",
"ifp",
"->",
"int_addr",
"==",
"addr",
")",
")",
")",
"return",
"ifp",
";",
"}",
"if",
"(",
"IF_RESCAN_DELAY",
"(",
")",
")",
"return",
"0",
";",
"ifinit",
"(",
")",
";",
"}",
"}"
] | find the interface with a name | [
"find",
"the",
"interface",
"with",
"a",
"name"
] | [
"/* \"ec0\" or whatever */",
"/* 0 or network address */",
"/* If the network address is not specified,\n\t\t\t * ignore any alias interfaces. Otherwise, look\n\t\t\t * for the interface with the target name and address.\n\t\t\t */",
"/* If there is no known interface, maybe there is a\n\t\t * new interface. So just once look for new interfaces.\n\t\t */"
] | [
{
"param": "name",
"type": "char"
},
{
"param": "addr",
"type": "naddr"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "name",
"type": "char",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "addr",
"type": "naddr",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
a772e09b8568cf55838f8697508b51befe07a6b5 | atrens/DragonFlyBSD-src | sbin/routed/if.c | [
"BSD-3-Clause"
] | C | iflookup | null | struct interface *
iflookup(naddr addr)
{
struct interface *ifp, *maybe;
maybe = NULL;
for (;;) {
for (ifp = ifnet; ifp; ifp = ifp->int_next) {
if (ifp->int_if_flags & IFF_POINTOPOINT) {
/* finished with a match */
if (ifp->int_dstaddr == addr)
return ifp;
} else {
/* finished with an exact match */
if (ifp->int_addr == addr)
return ifp;
/* Look for the longest approximate match.
*/
if (on_net(addr, ifp->int_net, ifp->int_mask)
&& (maybe == NULL
|| ifp->int_mask > maybe->int_mask))
maybe = ifp;
}
}
if (maybe != NULL
|| IF_RESCAN_DELAY())
return maybe;
/* If there is no known interface, maybe there is a
* new interface. So just once look for new interfaces.
*/
ifinit();
}
} | /* Find an interface from which the specified address
* should have come from. Used for figuring out which
* interface a packet came in on.
*/ | Find an interface from which the specified address
should have come from. Used for figuring out which
interface a packet came in on. | [
"Find",
"an",
"interface",
"from",
"which",
"the",
"specified",
"address",
"should",
"have",
"come",
"from",
".",
"Used",
"for",
"figuring",
"out",
"which",
"interface",
"a",
"packet",
"came",
"in",
"on",
"."
] | struct interface *
iflookup(naddr addr)
{
struct interface *ifp, *maybe;
maybe = NULL;
for (;;) {
for (ifp = ifnet; ifp; ifp = ifp->int_next) {
if (ifp->int_if_flags & IFF_POINTOPOINT) {
if (ifp->int_dstaddr == addr)
return ifp;
} else {
if (ifp->int_addr == addr)
return ifp;
if (on_net(addr, ifp->int_net, ifp->int_mask)
&& (maybe == NULL
|| ifp->int_mask > maybe->int_mask))
maybe = ifp;
}
}
if (maybe != NULL
|| IF_RESCAN_DELAY())
return maybe;
ifinit();
}
} | [
"struct",
"interface",
"*",
"iflookup",
"(",
"naddr",
"addr",
")",
"{",
"struct",
"interface",
"*",
"ifp",
",",
"*",
"maybe",
";",
"maybe",
"=",
"NULL",
";",
"for",
"(",
";",
";",
")",
"{",
"for",
"(",
"ifp",
"=",
"ifnet",
";",
"ifp",
";",
"ifp",
"=",
"ifp",
"->",
"int_next",
")",
"{",
"if",
"(",
"ifp",
"->",
"int_if_flags",
"&",
"IFF_POINTOPOINT",
")",
"{",
"if",
"(",
"ifp",
"->",
"int_dstaddr",
"==",
"addr",
")",
"return",
"ifp",
";",
"}",
"else",
"{",
"if",
"(",
"ifp",
"->",
"int_addr",
"==",
"addr",
")",
"return",
"ifp",
";",
"if",
"(",
"on_net",
"(",
"addr",
",",
"ifp",
"->",
"int_net",
",",
"ifp",
"->",
"int_mask",
")",
"&&",
"(",
"maybe",
"==",
"NULL",
"||",
"ifp",
"->",
"int_mask",
">",
"maybe",
"->",
"int_mask",
")",
")",
"maybe",
"=",
"ifp",
";",
"}",
"}",
"if",
"(",
"maybe",
"!=",
"NULL",
"||",
"IF_RESCAN_DELAY",
"(",
")",
")",
"return",
"maybe",
";",
"ifinit",
"(",
")",
";",
"}",
"}"
] | Find an interface from which the specified address
should have come from. | [
"Find",
"an",
"interface",
"from",
"which",
"the",
"specified",
"address",
"should",
"have",
"come",
"from",
"."
] | [
"/* finished with a match */",
"/* finished with an exact match */",
"/* Look for the longest approximate match.\n\t\t\t\t */",
"/* If there is no known interface, maybe there is a\n\t\t * new interface. So just once look for new interfaces.\n\t\t */"
] | [
{
"param": "addr",
"type": "naddr"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "addr",
"type": "naddr",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
a772e09b8568cf55838f8697508b51befe07a6b5 | atrens/DragonFlyBSD-src | sbin/routed/if.c | [
"BSD-3-Clause"
] | C | std_mask | naddr | naddr /* host byte order */
std_mask(naddr addr) /* network byte order */
{
addr = ntohl(addr); /* was a host, not a network */
if (addr == 0) /* default route has mask 0 */
return 0;
if (IN_CLASSA(addr))
return IN_CLASSA_NET;
if (IN_CLASSB(addr))
return IN_CLASSB_NET;
return IN_CLASSC_NET;
} | /* Return the classical netmask for an IP address.
*/ | Return the classical netmask for an IP address. | [
"Return",
"the",
"classical",
"netmask",
"for",
"an",
"IP",
"address",
"."
] | naddr
std_mask(naddr addr)
{
addr = ntohl(addr);
if (addr == 0)
return 0;
if (IN_CLASSA(addr))
return IN_CLASSA_NET;
if (IN_CLASSB(addr))
return IN_CLASSB_NET;
return IN_CLASSC_NET;
} | [
"naddr",
"std_mask",
"(",
"naddr",
"addr",
")",
"{",
"addr",
"=",
"ntohl",
"(",
"addr",
")",
";",
"if",
"(",
"addr",
"==",
"0",
")",
"return",
"0",
";",
"if",
"(",
"IN_CLASSA",
"(",
"addr",
")",
")",
"return",
"IN_CLASSA_NET",
";",
"if",
"(",
"IN_CLASSB",
"(",
"addr",
")",
")",
"return",
"IN_CLASSB_NET",
";",
"return",
"IN_CLASSC_NET",
";",
"}"
] | Return the classical netmask for an IP address. | [
"Return",
"the",
"classical",
"netmask",
"for",
"an",
"IP",
"address",
"."
] | [
"/* host byte order */",
"/* network byte order */",
"/* was a host, not a network */",
"/* default route has mask 0 */"
] | [
{
"param": "addr",
"type": "naddr"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "addr",
"type": "naddr",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
a772e09b8568cf55838f8697508b51befe07a6b5 | atrens/DragonFlyBSD-src | sbin/routed/if.c | [
"BSD-3-Clause"
] | C | ripv1_mask_net | naddr | naddr
ripv1_mask_net(naddr addr, /* in network byte order */
struct interface *ifp) /* as seen on this interface */
{
struct r1net *r1p;
naddr mask = 0;
if (addr == 0) /* default always has 0 mask */
return mask;
if (ifp != NULL && ifp->int_ripv1_mask != HOST_MASK) {
/* If the target network is that of the associated interface
* on which it arrived, then use the netmask of the interface.
*/
if (on_net(addr, ifp->int_net, ifp->int_std_mask))
mask = ifp->int_ripv1_mask;
} else {
/* Examine all interfaces, and if it the target seems
* to have the same network number of an interface, use the
* netmask of that interface. If there is more than one
* such interface, prefer the interface with the longest
* match.
*/
for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) {
if (on_net(addr, ifp->int_std_net, ifp->int_std_mask)
&& ifp->int_ripv1_mask > mask
&& ifp->int_ripv1_mask != HOST_MASK)
mask = ifp->int_ripv1_mask;
}
}
/* check special definitions */
if (mask == 0) {
for (r1p = r1nets; r1p != NULL; r1p = r1p->r1net_next) {
if (on_net(addr, r1p->r1net_net, r1p->r1net_match)
&& r1p->r1net_mask > mask)
mask = r1p->r1net_mask;
}
/* Otherwise, make the classic A/B/C guess.
*/
if (mask == 0)
mask = std_mask(addr);
}
return mask;
} | /* Find the netmask that would be inferred by RIPv1 listeners
* on the given interface for a given network.
* If no interface is specified, look for the best fitting interface.
*/ | Find the netmask that would be inferred by RIPv1 listeners
on the given interface for a given network.
If no interface is specified, look for the best fitting interface. | [
"Find",
"the",
"netmask",
"that",
"would",
"be",
"inferred",
"by",
"RIPv1",
"listeners",
"on",
"the",
"given",
"interface",
"for",
"a",
"given",
"network",
".",
"If",
"no",
"interface",
"is",
"specified",
"look",
"for",
"the",
"best",
"fitting",
"interface",
"."
] | naddr
ripv1_mask_net(naddr addr,
struct interface *ifp)
{
struct r1net *r1p;
naddr mask = 0;
if (addr == 0)
return mask;
if (ifp != NULL && ifp->int_ripv1_mask != HOST_MASK) {
if (on_net(addr, ifp->int_net, ifp->int_std_mask))
mask = ifp->int_ripv1_mask;
} else {
for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) {
if (on_net(addr, ifp->int_std_net, ifp->int_std_mask)
&& ifp->int_ripv1_mask > mask
&& ifp->int_ripv1_mask != HOST_MASK)
mask = ifp->int_ripv1_mask;
}
}
if (mask == 0) {
for (r1p = r1nets; r1p != NULL; r1p = r1p->r1net_next) {
if (on_net(addr, r1p->r1net_net, r1p->r1net_match)
&& r1p->r1net_mask > mask)
mask = r1p->r1net_mask;
}
if (mask == 0)
mask = std_mask(addr);
}
return mask;
} | [
"naddr",
"ripv1_mask_net",
"(",
"naddr",
"addr",
",",
"struct",
"interface",
"*",
"ifp",
")",
"{",
"struct",
"r1net",
"*",
"r1p",
";",
"naddr",
"mask",
"=",
"0",
";",
"if",
"(",
"addr",
"==",
"0",
")",
"return",
"mask",
";",
"if",
"(",
"ifp",
"!=",
"NULL",
"&&",
"ifp",
"->",
"int_ripv1_mask",
"!=",
"HOST_MASK",
")",
"{",
"if",
"(",
"on_net",
"(",
"addr",
",",
"ifp",
"->",
"int_net",
",",
"ifp",
"->",
"int_std_mask",
")",
")",
"mask",
"=",
"ifp",
"->",
"int_ripv1_mask",
";",
"}",
"else",
"{",
"for",
"(",
"ifp",
"=",
"ifnet",
";",
"ifp",
"!=",
"NULL",
";",
"ifp",
"=",
"ifp",
"->",
"int_next",
")",
"{",
"if",
"(",
"on_net",
"(",
"addr",
",",
"ifp",
"->",
"int_std_net",
",",
"ifp",
"->",
"int_std_mask",
")",
"&&",
"ifp",
"->",
"int_ripv1_mask",
">",
"mask",
"&&",
"ifp",
"->",
"int_ripv1_mask",
"!=",
"HOST_MASK",
")",
"mask",
"=",
"ifp",
"->",
"int_ripv1_mask",
";",
"}",
"}",
"if",
"(",
"mask",
"==",
"0",
")",
"{",
"for",
"(",
"r1p",
"=",
"r1nets",
";",
"r1p",
"!=",
"NULL",
";",
"r1p",
"=",
"r1p",
"->",
"r1net_next",
")",
"{",
"if",
"(",
"on_net",
"(",
"addr",
",",
"r1p",
"->",
"r1net_net",
",",
"r1p",
"->",
"r1net_match",
")",
"&&",
"r1p",
"->",
"r1net_mask",
">",
"mask",
")",
"mask",
"=",
"r1p",
"->",
"r1net_mask",
";",
"}",
"if",
"(",
"mask",
"==",
"0",
")",
"mask",
"=",
"std_mask",
"(",
"addr",
")",
";",
"}",
"return",
"mask",
";",
"}"
] | Find the netmask that would be inferred by RIPv1 listeners
on the given interface for a given network. | [
"Find",
"the",
"netmask",
"that",
"would",
"be",
"inferred",
"by",
"RIPv1",
"listeners",
"on",
"the",
"given",
"interface",
"for",
"a",
"given",
"network",
"."
] | [
"/* in network byte order */",
"/* as seen on this interface */",
"/* default always has 0 mask */",
"/* If the target network is that of the associated interface\n\t\t * on which it arrived, then use the netmask of the interface.\n\t\t */",
"/* Examine all interfaces, and if it the target seems\n\t\t * to have the same network number of an interface, use the\n\t\t * netmask of that interface. If there is more than one\n\t\t * such interface, prefer the interface with the longest\n\t\t * match.\n\t\t */",
"/* check special definitions */",
"/* Otherwise, make the classic A/B/C guess.\n\t\t */"
] | [
{
"param": "addr",
"type": "naddr"
},
{
"param": "ifp",
"type": "struct interface"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "addr",
"type": "naddr",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "ifp",
"type": "struct interface",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
a772e09b8568cf55838f8697508b51befe07a6b5 | atrens/DragonFlyBSD-src | sbin/routed/if.c | [
"BSD-3-Clause"
] | C | check_dst | int | int /* 0=bad */
check_dst(naddr addr)
{
addr = ntohl(addr);
if (IN_CLASSA(addr)) {
if (addr == 0)
return 1; /* default */
addr >>= IN_CLASSA_NSHIFT;
return (addr != 0 && addr != IN_LOOPBACKNET);
}
return (IN_CLASSB(addr) || IN_CLASSC(addr));
} | /* See if a IP address looks reasonable as a destination
*/ | See if a IP address looks reasonable as a destination | [
"See",
"if",
"a",
"IP",
"address",
"looks",
"reasonable",
"as",
"a",
"destination"
] | int
check_dst(naddr addr)
{
addr = ntohl(addr);
if (IN_CLASSA(addr)) {
if (addr == 0)
return 1;
addr >>= IN_CLASSA_NSHIFT;
return (addr != 0 && addr != IN_LOOPBACKNET);
}
return (IN_CLASSB(addr) || IN_CLASSC(addr));
} | [
"int",
"check_dst",
"(",
"naddr",
"addr",
")",
"{",
"addr",
"=",
"ntohl",
"(",
"addr",
")",
";",
"if",
"(",
"IN_CLASSA",
"(",
"addr",
")",
")",
"{",
"if",
"(",
"addr",
"==",
"0",
")",
"return",
"1",
";",
"addr",
">>=",
"IN_CLASSA_NSHIFT",
";",
"return",
"(",
"addr",
"!=",
"0",
"&&",
"addr",
"!=",
"IN_LOOPBACKNET",
")",
";",
"}",
"return",
"(",
"IN_CLASSB",
"(",
"addr",
")",
"||",
"IN_CLASSC",
"(",
"addr",
")",
")",
";",
"}"
] | See if a IP address looks reasonable as a destination | [
"See",
"if",
"a",
"IP",
"address",
"looks",
"reasonable",
"as",
"a",
"destination"
] | [
"/* 0=bad */",
"/* default */"
] | [
{
"param": "addr",
"type": "naddr"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "addr",
"type": "naddr",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
a772e09b8568cf55838f8697508b51befe07a6b5 | atrens/DragonFlyBSD-src | sbin/routed/if.c | [
"BSD-3-Clause"
] | C | check_dup | null | struct interface *
check_dup(naddr addr, /* IP address, so network byte order */
naddr dstaddr, /* ditto */
naddr mask, /* mask, so host byte order */
int if_flags)
{
struct interface *ifp;
for (ifp = ifnet; NULL != ifp; ifp = ifp->int_next) {
if (ifp->int_mask != mask)
continue;
if (!iff_up(ifp->int_if_flags))
continue;
/* The local address can only be shared with a point-to-point
* link.
*/
if (ifp->int_addr == addr
&& (((if_flags|ifp->int_if_flags) & IFF_POINTOPOINT) == 0))
return ifp;
if (on_net(ifp->int_dstaddr, ntohl(dstaddr),mask))
return ifp;
}
return 0;
} | /* See a new interface duplicates an existing interface.
*/ | See a new interface duplicates an existing interface. | [
"See",
"a",
"new",
"interface",
"duplicates",
"an",
"existing",
"interface",
"."
] | struct interface *
check_dup(naddr addr,
naddr dstaddr,
naddr mask,
int if_flags)
{
struct interface *ifp;
for (ifp = ifnet; NULL != ifp; ifp = ifp->int_next) {
if (ifp->int_mask != mask)
continue;
if (!iff_up(ifp->int_if_flags))
continue;
if (ifp->int_addr == addr
&& (((if_flags|ifp->int_if_flags) & IFF_POINTOPOINT) == 0))
return ifp;
if (on_net(ifp->int_dstaddr, ntohl(dstaddr),mask))
return ifp;
}
return 0;
} | [
"struct",
"interface",
"*",
"check_dup",
"(",
"naddr",
"addr",
",",
"naddr",
"dstaddr",
",",
"naddr",
"mask",
",",
"int",
"if_flags",
")",
"{",
"struct",
"interface",
"*",
"ifp",
";",
"for",
"(",
"ifp",
"=",
"ifnet",
";",
"NULL",
"!=",
"ifp",
";",
"ifp",
"=",
"ifp",
"->",
"int_next",
")",
"{",
"if",
"(",
"ifp",
"->",
"int_mask",
"!=",
"mask",
")",
"continue",
";",
"if",
"(",
"!",
"iff_up",
"(",
"ifp",
"->",
"int_if_flags",
")",
")",
"continue",
";",
"if",
"(",
"ifp",
"->",
"int_addr",
"==",
"addr",
"&&",
"(",
"(",
"(",
"if_flags",
"|",
"ifp",
"->",
"int_if_flags",
")",
"&",
"IFF_POINTOPOINT",
")",
"==",
"0",
")",
")",
"return",
"ifp",
";",
"if",
"(",
"on_net",
"(",
"ifp",
"->",
"int_dstaddr",
",",
"ntohl",
"(",
"dstaddr",
")",
",",
"mask",
")",
")",
"return",
"ifp",
";",
"}",
"return",
"0",
";",
"}"
] | See a new interface duplicates an existing interface. | [
"See",
"a",
"new",
"interface",
"duplicates",
"an",
"existing",
"interface",
"."
] | [
"/* IP address, so network byte order */",
"/* ditto */",
"/* mask, so host byte order */",
"/* The local address can only be shared with a point-to-point\n\t\t * link.\n\t\t */"
] | [
{
"param": "addr",
"type": "naddr"
},
{
"param": "dstaddr",
"type": "naddr"
},
{
"param": "mask",
"type": "naddr"
},
{
"param": "if_flags",
"type": "int"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "addr",
"type": "naddr",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "dstaddr",
"type": "naddr",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "mask",
"type": "naddr",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "if_flags",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
a772e09b8568cf55838f8697508b51befe07a6b5 | atrens/DragonFlyBSD-src | sbin/routed/if.c | [
"BSD-3-Clause"
] | C | addrouteforif | int | int /* 0=bad interface */
addrouteforif(struct interface *ifp)
{
struct rt_entry *rt;
static struct rt_spare new;
naddr dst;
/* skip sick interfaces
*/
if (ifp->int_state & IS_BROKE)
return 0;
/* If the interface on a subnet, then install a RIPv1 route to
* the network as well (unless it is sick).
*/
if (ifp->int_state & IS_SUBNET)
check_net_syn(ifp);
dst = (0 != (ifp->int_if_flags & (IFF_POINTOPOINT | IFF_LOOPBACK))
? ifp->int_dstaddr
: htonl(ifp->int_net));
new.rts_ifp = ifp;
new.rts_router = ifp->int_addr;
new.rts_gate = ifp->int_addr;
new.rts_metric = ifp->int_metric;
new.rts_time = now.tv_sec;
/* If we are going to send packets to the gateway,
* it must be reachable using our physical interfaces
*/
if ((ifp->int_state & IS_REMOTE)
&& !(ifp->int_state & IS_EXTERNAL)
&& !check_remote(ifp))
return 0;
/* We are finished if the correct main interface route exists.
* The right route must be for the right interface, not synthesized
* from a subnet, be a "gateway" or not as appropriate, and so forth.
*/
del_static(dst, ifp->int_mask, 0, 0);
rt = rtget(dst, ifp->int_mask);
if (rt != NULL) {
if ((rt->rt_ifp != ifp
|| rt->rt_router != ifp->int_addr)
&& (!(ifp->int_state & IS_DUP)
|| rt->rt_ifp == 0
|| (rt->rt_ifp->int_state & IS_BROKE))) {
rtdelete(rt);
rt = NULL;
} else {
rtchange(rt, ((rt->rt_state | RS_IF)
& ~(RS_NET_SYN | RS_LOCAL)),
&new, 0);
}
}
if (rt == NULL) {
if (ifp->int_transitions++ > 0)
trace_act("re-install interface %s",
ifp->int_name);
rtadd(dst, ifp->int_mask, RS_IF, &new);
}
return 1;
} | /* Add route for interface if not currently installed.
* Create route to other end if a point-to-point link,
* otherwise a route to this (sub)network.
*/ | Add route for interface if not currently installed.
Create route to other end if a point-to-point link,
otherwise a route to this (sub)network. | [
"Add",
"route",
"for",
"interface",
"if",
"not",
"currently",
"installed",
".",
"Create",
"route",
"to",
"other",
"end",
"if",
"a",
"point",
"-",
"to",
"-",
"point",
"link",
"otherwise",
"a",
"route",
"to",
"this",
"(",
"sub",
")",
"network",
"."
] | int
addrouteforif(struct interface *ifp)
{
struct rt_entry *rt;
static struct rt_spare new;
naddr dst;
if (ifp->int_state & IS_BROKE)
return 0;
if (ifp->int_state & IS_SUBNET)
check_net_syn(ifp);
dst = (0 != (ifp->int_if_flags & (IFF_POINTOPOINT | IFF_LOOPBACK))
? ifp->int_dstaddr
: htonl(ifp->int_net));
new.rts_ifp = ifp;
new.rts_router = ifp->int_addr;
new.rts_gate = ifp->int_addr;
new.rts_metric = ifp->int_metric;
new.rts_time = now.tv_sec;
if ((ifp->int_state & IS_REMOTE)
&& !(ifp->int_state & IS_EXTERNAL)
&& !check_remote(ifp))
return 0;
del_static(dst, ifp->int_mask, 0, 0);
rt = rtget(dst, ifp->int_mask);
if (rt != NULL) {
if ((rt->rt_ifp != ifp
|| rt->rt_router != ifp->int_addr)
&& (!(ifp->int_state & IS_DUP)
|| rt->rt_ifp == 0
|| (rt->rt_ifp->int_state & IS_BROKE))) {
rtdelete(rt);
rt = NULL;
} else {
rtchange(rt, ((rt->rt_state | RS_IF)
& ~(RS_NET_SYN | RS_LOCAL)),
&new, 0);
}
}
if (rt == NULL) {
if (ifp->int_transitions++ > 0)
trace_act("re-install interface %s",
ifp->int_name);
rtadd(dst, ifp->int_mask, RS_IF, &new);
}
return 1;
} | [
"int",
"addrouteforif",
"(",
"struct",
"interface",
"*",
"ifp",
")",
"{",
"struct",
"rt_entry",
"*",
"rt",
";",
"static",
"struct",
"rt_spare",
"new",
";",
"naddr",
"dst",
";",
"if",
"(",
"ifp",
"->",
"int_state",
"&",
"IS_BROKE",
")",
"return",
"0",
";",
"if",
"(",
"ifp",
"->",
"int_state",
"&",
"IS_SUBNET",
")",
"check_net_syn",
"(",
"ifp",
")",
";",
"dst",
"=",
"(",
"0",
"!=",
"(",
"ifp",
"->",
"int_if_flags",
"&",
"(",
"IFF_POINTOPOINT",
"|",
"IFF_LOOPBACK",
")",
")",
"?",
"ifp",
"->",
"int_dstaddr",
":",
"htonl",
"(",
"ifp",
"->",
"int_net",
")",
")",
";",
"new",
".",
"rts_ifp",
"=",
"ifp",
";",
"new",
".",
"rts_router",
"=",
"ifp",
"->",
"int_addr",
";",
"new",
".",
"rts_gate",
"=",
"ifp",
"->",
"int_addr",
";",
"new",
".",
"rts_metric",
"=",
"ifp",
"->",
"int_metric",
";",
"new",
".",
"rts_time",
"=",
"now",
".",
"tv_sec",
";",
"if",
"(",
"(",
"ifp",
"->",
"int_state",
"&",
"IS_REMOTE",
")",
"&&",
"!",
"(",
"ifp",
"->",
"int_state",
"&",
"IS_EXTERNAL",
")",
"&&",
"!",
"check_remote",
"(",
"ifp",
")",
")",
"return",
"0",
";",
"del_static",
"(",
"dst",
",",
"ifp",
"->",
"int_mask",
",",
"0",
",",
"0",
")",
";",
"rt",
"=",
"rtget",
"(",
"dst",
",",
"ifp",
"->",
"int_mask",
")",
";",
"if",
"(",
"rt",
"!=",
"NULL",
")",
"{",
"if",
"(",
"(",
"rt",
"->",
"rt_ifp",
"!=",
"ifp",
"||",
"rt",
"->",
"rt_router",
"!=",
"ifp",
"->",
"int_addr",
")",
"&&",
"(",
"!",
"(",
"ifp",
"->",
"int_state",
"&",
"IS_DUP",
")",
"||",
"rt",
"->",
"rt_ifp",
"==",
"0",
"||",
"(",
"rt",
"->",
"rt_ifp",
"->",
"int_state",
"&",
"IS_BROKE",
")",
")",
")",
"{",
"rtdelete",
"(",
"rt",
")",
";",
"rt",
"=",
"NULL",
";",
"}",
"else",
"{",
"rtchange",
"(",
"rt",
",",
"(",
"(",
"rt",
"->",
"rt_state",
"|",
"RS_IF",
")",
"&",
"~",
"(",
"RS_NET_SYN",
"|",
"RS_LOCAL",
")",
")",
",",
"&",
"new",
",",
"0",
")",
";",
"}",
"}",
"if",
"(",
"rt",
"==",
"NULL",
")",
"{",
"if",
"(",
"ifp",
"->",
"int_transitions",
"++",
">",
"0",
")",
"trace_act",
"(",
"\"",
"\"",
",",
"ifp",
"->",
"int_name",
")",
";",
"rtadd",
"(",
"dst",
",",
"ifp",
"->",
"int_mask",
",",
"RS_IF",
",",
"&",
"new",
")",
";",
"}",
"return",
"1",
";",
"}"
] | Add route for interface if not currently installed. | [
"Add",
"route",
"for",
"interface",
"if",
"not",
"currently",
"installed",
"."
] | [
"/* 0=bad interface */",
"/* skip sick interfaces\n\t */",
"/* If the interface on a subnet, then install a RIPv1 route to\n\t * the network as well (unless it is sick).\n\t */",
"/* If we are going to send packets to the gateway,\n\t * it must be reachable using our physical interfaces\n\t */",
"/* We are finished if the correct main interface route exists.\n\t * The right route must be for the right interface, not synthesized\n\t * from a subnet, be a \"gateway\" or not as appropriate, and so forth.\n\t */"
] | [
{
"param": "ifp",
"type": "struct interface"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "ifp",
"type": "struct interface",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
af67feb5fbc7c8cad8d1b694c07dd549d0c0fa3d | atrens/DragonFlyBSD-src | contrib/gcc-8.0/gcc/fold-const.c | [
"BSD-3-Clause"
] | C | expr_location_or | location_t | static location_t
expr_location_or (tree t, location_t loc)
{
location_t tloc = EXPR_LOCATION (t);
return tloc == UNKNOWN_LOCATION ? loc : tloc;
} | /* Return EXPR_LOCATION of T if it is not UNKNOWN_LOCATION.
Otherwise, return LOC. */ | Return EXPR_LOCATION of T if it is not UNKNOWN_LOCATION.
Otherwise, return LOC. | [
"Return",
"EXPR_LOCATION",
"of",
"T",
"if",
"it",
"is",
"not",
"UNKNOWN_LOCATION",
".",
"Otherwise",
"return",
"LOC",
"."
] | static location_t
expr_location_or (tree t, location_t loc)
{
location_t tloc = EXPR_LOCATION (t);
return tloc == UNKNOWN_LOCATION ? loc : tloc;
} | [
"static",
"location_t",
"expr_location_or",
"(",
"tree",
"t",
",",
"location_t",
"loc",
")",
"{",
"location_t",
"tloc",
"=",
"EXPR_LOCATION",
"(",
"t",
")",
";",
"return",
"tloc",
"==",
"UNKNOWN_LOCATION",
"?",
"loc",
":",
"tloc",
";",
"}"
] | Return EXPR_LOCATION of T if it is not UNKNOWN_LOCATION. | [
"Return",
"EXPR_LOCATION",
"of",
"T",
"if",
"it",
"is",
"not",
"UNKNOWN_LOCATION",
"."
] | [] | [
{
"param": "t",
"type": "tree"
},
{
"param": "loc",
"type": "location_t"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "t",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "loc",
"type": "location_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
af67feb5fbc7c8cad8d1b694c07dd549d0c0fa3d | atrens/DragonFlyBSD-src | contrib/gcc-8.0/gcc/fold-const.c | [
"BSD-3-Clause"
] | C | protected_set_expr_location_unshare | tree | static inline tree
protected_set_expr_location_unshare (tree x, location_t loc)
{
if (CAN_HAVE_LOCATION_P (x)
&& EXPR_LOCATION (x) != loc
&& !(TREE_CODE (x) == SAVE_EXPR
|| TREE_CODE (x) == TARGET_EXPR
|| TREE_CODE (x) == BIND_EXPR))
{
x = copy_node (x);
SET_EXPR_LOCATION (x, loc);
}
return x;
} | /* Similar to protected_set_expr_location, but never modify x in place,
if location can and needs to be set, unshare it. */ | Similar to protected_set_expr_location, but never modify x in place,
if location can and needs to be set, unshare it. | [
"Similar",
"to",
"protected_set_expr_location",
"but",
"never",
"modify",
"x",
"in",
"place",
"if",
"location",
"can",
"and",
"needs",
"to",
"be",
"set",
"unshare",
"it",
"."
] | static inline tree
protected_set_expr_location_unshare (tree x, location_t loc)
{
if (CAN_HAVE_LOCATION_P (x)
&& EXPR_LOCATION (x) != loc
&& !(TREE_CODE (x) == SAVE_EXPR
|| TREE_CODE (x) == TARGET_EXPR
|| TREE_CODE (x) == BIND_EXPR))
{
x = copy_node (x);
SET_EXPR_LOCATION (x, loc);
}
return x;
} | [
"static",
"inline",
"tree",
"protected_set_expr_location_unshare",
"(",
"tree",
"x",
",",
"location_t",
"loc",
")",
"{",
"if",
"(",
"CAN_HAVE_LOCATION_P",
"(",
"x",
")",
"&&",
"EXPR_LOCATION",
"(",
"x",
")",
"!=",
"loc",
"&&",
"!",
"(",
"TREE_CODE",
"(",
"x",
")",
"==",
"SAVE_EXPR",
"||",
"TREE_CODE",
"(",
"x",
")",
"==",
"TARGET_EXPR",
"||",
"TREE_CODE",
"(",
"x",
")",
"==",
"BIND_EXPR",
")",
")",
"{",
"x",
"=",
"copy_node",
"(",
"x",
")",
";",
"SET_EXPR_LOCATION",
"(",
"x",
",",
"loc",
")",
";",
"}",
"return",
"x",
";",
"}"
] | Similar to protected_set_expr_location, but never modify x in place,
if location can and needs to be set, unshare it. | [
"Similar",
"to",
"protected_set_expr_location",
"but",
"never",
"modify",
"x",
"in",
"place",
"if",
"location",
"can",
"and",
"needs",
"to",
"be",
"set",
"unshare",
"it",
"."
] | [] | [
{
"param": "x",
"type": "tree"
},
{
"param": "loc",
"type": "location_t"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "x",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "loc",
"type": "location_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
af67feb5fbc7c8cad8d1b694c07dd549d0c0fa3d | atrens/DragonFlyBSD-src | contrib/gcc-8.0/gcc/fold-const.c | [
"BSD-3-Clause"
] | C | fold_defer_overflow_warnings | void | void
fold_defer_overflow_warnings (void)
{
++fold_deferring_overflow_warnings;
} | /* Start deferring overflow warnings. We could use a stack here to
permit nested calls, but at present it is not necessary. */ | Start deferring overflow warnings. We could use a stack here to
permit nested calls, but at present it is not necessary. | [
"Start",
"deferring",
"overflow",
"warnings",
".",
"We",
"could",
"use",
"a",
"stack",
"here",
"to",
"permit",
"nested",
"calls",
"but",
"at",
"present",
"it",
"is",
"not",
"necessary",
"."
] | void
fold_defer_overflow_warnings (void)
{
++fold_deferring_overflow_warnings;
} | [
"void",
"fold_defer_overflow_warnings",
"(",
"void",
")",
"{",
"++",
"fold_deferring_overflow_warnings",
";",
"}"
] | Start deferring overflow warnings. | [
"Start",
"deferring",
"overflow",
"warnings",
"."
] | [] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
af67feb5fbc7c8cad8d1b694c07dd549d0c0fa3d | atrens/DragonFlyBSD-src | contrib/gcc-8.0/gcc/fold-const.c | [
"BSD-3-Clause"
] | C | fold_undefer_overflow_warnings | void | void
fold_undefer_overflow_warnings (bool issue, const gimple *stmt, int code)
{
const char *warnmsg;
location_t locus;
gcc_assert (fold_deferring_overflow_warnings > 0);
--fold_deferring_overflow_warnings;
if (fold_deferring_overflow_warnings > 0)
{
if (fold_deferred_overflow_warning != NULL
&& code != 0
&& code < (int) fold_deferred_overflow_code)
fold_deferred_overflow_code = (enum warn_strict_overflow_code) code;
return;
}
warnmsg = fold_deferred_overflow_warning;
fold_deferred_overflow_warning = NULL;
if (!issue || warnmsg == NULL)
return;
if (gimple_no_warning_p (stmt))
return;
/* Use the smallest code level when deciding to issue the
warning. */
if (code == 0 || code > (int) fold_deferred_overflow_code)
code = fold_deferred_overflow_code;
if (!issue_strict_overflow_warning (code))
return;
if (stmt == NULL)
locus = input_location;
else
locus = gimple_location (stmt);
warning_at (locus, OPT_Wstrict_overflow, "%s", warnmsg);
} | /* Stop deferring overflow warnings. If there is a pending warning,
and ISSUE is true, then issue the warning if appropriate. STMT is
the statement with which the warning should be associated (used for
location information); STMT may be NULL. CODE is the level of the
warning--a warn_strict_overflow_code value. This function will use
the smaller of CODE and the deferred code when deciding whether to
issue the warning. CODE may be zero to mean to always use the
deferred code. */ | Stop deferring overflow warnings. If there is a pending warning,
and ISSUE is true, then issue the warning if appropriate. STMT is
the statement with which the warning should be associated (used for
location information); STMT may be NULL. CODE is the level of the
warning--a warn_strict_overflow_code value. This function will use
the smaller of CODE and the deferred code when deciding whether to
issue the warning. CODE may be zero to mean to always use the
deferred code. | [
"Stop",
"deferring",
"overflow",
"warnings",
".",
"If",
"there",
"is",
"a",
"pending",
"warning",
"and",
"ISSUE",
"is",
"true",
"then",
"issue",
"the",
"warning",
"if",
"appropriate",
".",
"STMT",
"is",
"the",
"statement",
"with",
"which",
"the",
"warning",
"should",
"be",
"associated",
"(",
"used",
"for",
"location",
"information",
")",
";",
"STMT",
"may",
"be",
"NULL",
".",
"CODE",
"is",
"the",
"level",
"of",
"the",
"warning",
"--",
"a",
"warn_strict_overflow_code",
"value",
".",
"This",
"function",
"will",
"use",
"the",
"smaller",
"of",
"CODE",
"and",
"the",
"deferred",
"code",
"when",
"deciding",
"whether",
"to",
"issue",
"the",
"warning",
".",
"CODE",
"may",
"be",
"zero",
"to",
"mean",
"to",
"always",
"use",
"the",
"deferred",
"code",
"."
] | void
fold_undefer_overflow_warnings (bool issue, const gimple *stmt, int code)
{
const char *warnmsg;
location_t locus;
gcc_assert (fold_deferring_overflow_warnings > 0);
--fold_deferring_overflow_warnings;
if (fold_deferring_overflow_warnings > 0)
{
if (fold_deferred_overflow_warning != NULL
&& code != 0
&& code < (int) fold_deferred_overflow_code)
fold_deferred_overflow_code = (enum warn_strict_overflow_code) code;
return;
}
warnmsg = fold_deferred_overflow_warning;
fold_deferred_overflow_warning = NULL;
if (!issue || warnmsg == NULL)
return;
if (gimple_no_warning_p (stmt))
return;
if (code == 0 || code > (int) fold_deferred_overflow_code)
code = fold_deferred_overflow_code;
if (!issue_strict_overflow_warning (code))
return;
if (stmt == NULL)
locus = input_location;
else
locus = gimple_location (stmt);
warning_at (locus, OPT_Wstrict_overflow, "%s", warnmsg);
} | [
"void",
"fold_undefer_overflow_warnings",
"(",
"bool",
"issue",
",",
"const",
"gimple",
"*",
"stmt",
",",
"int",
"code",
")",
"{",
"const",
"char",
"*",
"warnmsg",
";",
"location_t",
"locus",
";",
"gcc_assert",
"(",
"fold_deferring_overflow_warnings",
">",
"0",
")",
";",
"--",
"fold_deferring_overflow_warnings",
";",
"if",
"(",
"fold_deferring_overflow_warnings",
">",
"0",
")",
"{",
"if",
"(",
"fold_deferred_overflow_warning",
"!=",
"NULL",
"&&",
"code",
"!=",
"0",
"&&",
"code",
"<",
"(",
"int",
")",
"fold_deferred_overflow_code",
")",
"fold_deferred_overflow_code",
"=",
"(",
"enum",
"warn_strict_overflow_code",
")",
"code",
";",
"return",
";",
"}",
"warnmsg",
"=",
"fold_deferred_overflow_warning",
";",
"fold_deferred_overflow_warning",
"=",
"NULL",
";",
"if",
"(",
"!",
"issue",
"||",
"warnmsg",
"==",
"NULL",
")",
"return",
";",
"if",
"(",
"gimple_no_warning_p",
"(",
"stmt",
")",
")",
"return",
";",
"if",
"(",
"code",
"==",
"0",
"||",
"code",
">",
"(",
"int",
")",
"fold_deferred_overflow_code",
")",
"code",
"=",
"fold_deferred_overflow_code",
";",
"if",
"(",
"!",
"issue_strict_overflow_warning",
"(",
"code",
")",
")",
"return",
";",
"if",
"(",
"stmt",
"==",
"NULL",
")",
"locus",
"=",
"input_location",
";",
"else",
"locus",
"=",
"gimple_location",
"(",
"stmt",
")",
";",
"warning_at",
"(",
"locus",
",",
"OPT_Wstrict_overflow",
",",
"\"",
"\"",
",",
"warnmsg",
")",
";",
"}"
] | Stop deferring overflow warnings. | [
"Stop",
"deferring",
"overflow",
"warnings",
"."
] | [
"/* Use the smallest code level when deciding to issue the\n warning. */"
] | [
{
"param": "issue",
"type": "bool"
},
{
"param": "stmt",
"type": "gimple"
},
{
"param": "code",
"type": "int"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "issue",
"type": "bool",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "stmt",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "code",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
af67feb5fbc7c8cad8d1b694c07dd549d0c0fa3d | atrens/DragonFlyBSD-src | contrib/gcc-8.0/gcc/fold-const.c | [
"BSD-3-Clause"
] | C | fold_undefer_and_ignore_overflow_warnings | void | void
fold_undefer_and_ignore_overflow_warnings (void)
{
fold_undefer_overflow_warnings (false, NULL, 0);
} | /* Stop deferring overflow warnings, ignoring any deferred
warnings. */ | Stop deferring overflow warnings, ignoring any deferred
warnings. | [
"Stop",
"deferring",
"overflow",
"warnings",
"ignoring",
"any",
"deferred",
"warnings",
"."
] | void
fold_undefer_and_ignore_overflow_warnings (void)
{
fold_undefer_overflow_warnings (false, NULL, 0);
} | [
"void",
"fold_undefer_and_ignore_overflow_warnings",
"(",
"void",
")",
"{",
"fold_undefer_overflow_warnings",
"(",
"false",
",",
"NULL",
",",
"0",
")",
";",
"}"
] | Stop deferring overflow warnings, ignoring any deferred
warnings. | [
"Stop",
"deferring",
"overflow",
"warnings",
"ignoring",
"any",
"deferred",
"warnings",
"."
] | [] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.