static int
symtable_warn(struct symtable *st, char *msg, int lineno)
{
if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, st->st_filename,
lineno, NULL, NULL) < 0) {
if (PyErr_ExceptionMatches(PyExc_SyntaxWarning)) {
PyErr_SetString(PyExc_SyntaxError, msg);
PyErr_SyntaxLocation(st->st_filename,
st->st_cur->ste_lineno);
}
return 0;
}
return 1;
}
/**
* Call this function for each callback. Note that even if this function
* returns nonzero, CB_THR_BEGIN() must still be called, and the `conn`
* and `mres` out parameters are considered valid
* @param resp base response object
* @param[out] conn the bucket object
* @param[out] res the result object for the individual operation
* @param restype What type should `res` be if it needs to be created
* @param[out] mres the context for the current operation
* @return 0 if operation processing may proceed, nonzero if operation
* processing has completed. In both cases the `conn` and `mres` paramters
* are valid, however.
*/
static int
get_common_objects(const lcb_RESPBASE *resp, pycbc_Bucket **conn,
pycbc_Result **res, int restype, pycbc_MultiResult **mres)
{
PyObject *hkey;
PyObject *mrdict;
int rv;
pycbc_assert(pycbc_multiresult_check(resp->cookie));
*mres = (pycbc_MultiResult*)resp->cookie;
*conn = (*mres)->parent;
CB_THR_END(*conn);
rv = pycbc_tc_decode_key(*conn, resp->key, resp->nkey, &hkey);
if (rv < 0) {
pycbc_multiresult_adderr(*mres);
return -1;
}
mrdict = pycbc_multiresult_dict(*mres);
*res = (pycbc_Result*)PyDict_GetItem(mrdict, hkey);
if (*res) {
int exists_ok = (restype & RESTYPE_EXISTS_OK) ||
( (*mres)->mropts & PYCBC_MRES_F_UALLOCED);
if (!exists_ok) {
if ((*conn)->flags & PYCBC_CONN_F_WARNEXPLICIT) {
PyErr_WarnExplicit(PyExc_RuntimeWarning,
"Found duplicate key",
__FILE__, __LINE__,
"couchbase._libcouchbase",
NULL);
} else {
PyErr_WarnEx(PyExc_RuntimeWarning,
"Found duplicate key",
1);
}
/**
* We need to destroy the existing object and re-create it.
*/
PyDict_DelItem(mrdict, hkey);
*res = NULL;
} else {
Py_XDECREF(hkey);
}
}
if (*res == NULL) {
/* Now, get/set the result object */
if ( (*mres)->mropts & PYCBC_MRES_F_ITEMS) {
*res = (pycbc_Result*)pycbc_item_new(*conn);
} else if (restype & RESTYPE_BASE) {
*res = (pycbc_Result*)pycbc_result_new(*conn);
} else if (restype & RESTYPE_OPERATION) {
*res = (pycbc_Result*)pycbc_opresult_new(*conn);
} else if (restype & RESTYPE_VALUE) {
*res = (pycbc_Result*)pycbc_valresult_new(*conn);
} else {
abort();
}
PyDict_SetItem(mrdict, hkey, (PyObject*)*res);
(*res)->key = hkey;
Py_DECREF(*res);
}
if (resp->rc) {
(*res)->rc = resp->rc;
}
if (resp->rc != LCB_SUCCESS) {
(*mres)->all_ok = 0;
}
return 0;
}
static int
tok_get(register struct tok_state *tok, char **p_start, char **p_end)
{
register int c;
int blankline;
*p_start = *p_end = NULL;
nextline:
tok->start = NULL;
blankline = 0;
/* Get indentation level */
if (tok->atbol) {
register int col = 0;
register int altcol = 0;
tok->atbol = 0;
for (;;) {
c = tok_nextc(tok);
if (c == ' ')
col++, altcol++;
else if (c == '\t') {
col = (col/tok->tabsize + 1) * tok->tabsize;
altcol = (altcol/tok->alttabsize + 1)
* tok->alttabsize;
}
else if (c == '\014') /* Control-L (formfeed) */
col = altcol = 0; /* For Emacs users */
else
break;
}
tok_backup(tok, c);
if (c == '#' || c == '\n') {
/* Lines with only whitespace and/or comments
shouldn't affect the indentation and are
not passed to the parser as NEWLINE tokens,
except *totally* empty lines in interactive
mode, which signal the end of a command group. */
if (col == 0 && c == '\n' && tok->prompt != NULL)
blankline = 0; /* Let it through */
else
blankline = 1; /* Ignore completely */
/* We can't jump back right here since we still
may need to skip to the end of a comment */
}
if (!blankline && tok->level == 0) {
if (col == tok->indstack[tok->indent]) {
/* No change */
if (altcol != tok->altindstack[tok->indent]) {
if (indenterror(tok))
return ERRORTOKEN;
}
}
else if (col > tok->indstack[tok->indent]) {
/* Indent -- always one */
if (tok->indent+1 >= MAXINDENT) {
tok->done = E_TOODEEP;
tok->cur = tok->inp;
return ERRORTOKEN;
}
if (altcol <= tok->altindstack[tok->indent]) {
if (indenterror(tok))
return ERRORTOKEN;
}
tok->pendin++;
tok->indstack[++tok->indent] = col;
tok->altindstack[tok->indent] = altcol;
}
else /* col < tok->indstack[tok->indent] */ {
/* Dedent -- any number, must be consistent */
while (tok->indent > 0 &&
col < tok->indstack[tok->indent]) {
tok->pendin--;
tok->indent--;
}
if (col != tok->indstack[tok->indent]) {
tok->done = E_DEDENT;
tok->cur = tok->inp;
return ERRORTOKEN;
}
if (altcol != tok->altindstack[tok->indent]) {
if (indenterror(tok))
return ERRORTOKEN;
}
}
}
}
tok->start = tok->cur;
/* Return pending indents/dedents */
if (tok->pendin != 0) {
if (tok->pendin < 0) {
tok->pendin++;
return DEDENT;
}
else {
tok->pendin--;
return INDENT;
}
}
again:
tok->start = NULL;
/* Skip spaces */
do {
c = tok_nextc(tok);
} while (c == ' ' || c == '\t' || c == '\014');
/* Set start of current token */
tok->start = tok->cur - 1;
/* Skip comment, while looking for tab-setting magic */
if (c == '#') {
static char *tabforms[] = {
"tab-width:", /* Emacs */
":tabstop=", /* vim, full form */
":ts=", /* vim, abbreviated form */
"set tabsize=", /* will vi never die? */
/* more templates can be added here to support other editors */
};
char cbuf[80];
char *tp, **cp;
tp = cbuf;
do {
*tp++ = c = tok_nextc(tok);
} while (c != EOF && c != '\n' &&
(size_t)(tp - cbuf + 1) < sizeof(cbuf));
*tp = '\0';
for (cp = tabforms;
cp < tabforms + sizeof(tabforms)/sizeof(tabforms[0]);
cp++) {
if ((tp = strstr(cbuf, *cp))) {
int newsize = atoi(tp + strlen(*cp));
if (newsize >= 1 && newsize <= 40) {
tok->tabsize = newsize;
if (Py_VerboseFlag)
PySys_WriteStderr(
"Tab size set to %d\n",
newsize);
}
}
}
while (c != EOF && c != '\n')
c = tok_nextc(tok);
}
/* Check for EOF and errors now */
if (c == EOF) {
return tok->done == E_EOF ? ENDMARKER : ERRORTOKEN;
}
/* Identifier (most frequent token!) */
if (isalpha(c) || c == '_') {
/* Process r"", u"" and ur"" */
switch (c) {
case 'b':
case 'B':
c = tok_nextc(tok);
if (c == 'r' || c == 'R')
c = tok_nextc(tok);
if (c == '"' || c == '\'')
goto letter_quote;
break;
case 'r':
case 'R':
c = tok_nextc(tok);
if (c == '"' || c == '\'')
goto letter_quote;
break;
case 'u':
case 'U':
c = tok_nextc(tok);
if (c == 'r' || c == 'R')
c = tok_nextc(tok);
if (c == '"' || c == '\'')
goto letter_quote;
break;
}
while (isalnum(c) || c == '_') {
c = tok_nextc(tok);
}
tok_backup(tok, c);
*p_start = tok->start;
*p_end = tok->cur;
return NAME;
}
/* Newline */
if (c == '\n') {
tok->atbol = 1;
if (blankline || tok->level > 0)
goto nextline;
*p_start = tok->start;
*p_end = tok->cur - 1; /* Leave '\n' out of the string */
tok->cont_line = 0;
return NEWLINE;
}
/* Period or number starting with period? */
if (c == '.') {
c = tok_nextc(tok);
if (isdigit(c)) {
goto fraction;
}
else {
tok_backup(tok, c);
*p_start = tok->start;
*p_end = tok->cur;
return DOT;
}
}
/* Number */
if (isdigit(c)) {
if (c == '0') {
/* Hex, octal or binary -- maybe. */
c = tok_nextc(tok);
if (c == '.')
goto fraction;
#ifndef WITHOUT_COMPLEX
if (c == 'j' || c == 'J')
goto imaginary;
#endif
if (c == 'x' || c == 'X') {
/* Hex */
c = tok_nextc(tok);
if (!isxdigit(c)) {
tok->done = E_TOKEN;
tok_backup(tok, c);
return ERRORTOKEN;
}
do {
c = tok_nextc(tok);
} while (isxdigit(c));
}
else if (c == 'o' || c == 'O') {
/* Octal */
c = tok_nextc(tok);
if (c < '0' || c >= '8') {
tok->done = E_TOKEN;
tok_backup(tok, c);
return ERRORTOKEN;
}
do {
c = tok_nextc(tok);
} while ('0' <= c && c < '8');
}
else if (c == 'b' || c == 'B') {
/* Binary */
c = tok_nextc(tok);
if (c != '0' && c != '1') {
tok->done = E_TOKEN;
tok_backup(tok, c);
return ERRORTOKEN;
}
do {
c = tok_nextc(tok);
} while (c == '0' || c == '1');
}
else {
int found_decimal = 0;
/* Octal; c is first char of it */
/* There's no 'isoctdigit' macro, sigh */
while ('0' <= c && c < '8') {
c = tok_nextc(tok);
}
if (isdigit(c)) {
found_decimal = 1;
do {
c = tok_nextc(tok);
} while (isdigit(c));
}
if (c == '.')
goto fraction;
else if (c == 'e' || c == 'E')
goto exponent;
#ifndef WITHOUT_COMPLEX
else if (c == 'j' || c == 'J')
goto imaginary;
#endif
else if (found_decimal) {
tok->done = E_TOKEN;
tok_backup(tok, c);
return ERRORTOKEN;
}
}
if (c == 'l' || c == 'L')
c = tok_nextc(tok);
}
else {
/* Decimal */
do {
c = tok_nextc(tok);
} while (isdigit(c));
if (c == 'l' || c == 'L')
c = tok_nextc(tok);
else {
/* Accept floating point numbers. */
if (c == '.') {
fraction:
/* Fraction */
do {
c = tok_nextc(tok);
} while (isdigit(c));
}
if (c == 'e' || c == 'E') {
exponent:
/* Exponent part */
c = tok_nextc(tok);
if (c == '+' || c == '-')
c = tok_nextc(tok);
if (!isdigit(c)) {
tok->done = E_TOKEN;
tok_backup(tok, c);
return ERRORTOKEN;
}
do {
c = tok_nextc(tok);
} while (isdigit(c));
}
#ifndef WITHOUT_COMPLEX
if (c == 'j' || c == 'J')
/* Imaginary part */
imaginary:
c = tok_nextc(tok);
#endif
}
}
tok_backup(tok, c);
*p_start = tok->start;
*p_end = tok->cur;
return NUMBER;
}
letter_quote:
/* String */
if (c == '\'' || c == '"') {
Py_ssize_t quote2 = tok->cur - tok->start + 1;
int quote = c;
int triple = 0;
int tripcount = 0;
for (;;) {
c = tok_nextc(tok);
if (c == '\n') {
if (!triple) {
tok->done = E_EOLS;
tok_backup(tok, c);
return ERRORTOKEN;
}
tripcount = 0;
tok->cont_line = 1; /* multiline string. */
}
else if (c == EOF) {
if (triple)
tok->done = E_EOFS;
else
tok->done = E_EOLS;
tok->cur = tok->inp;
return ERRORTOKEN;
}
else if (c == quote) {
tripcount++;
if (tok->cur - tok->start == quote2) {
c = tok_nextc(tok);
if (c == quote) {
triple = 1;
tripcount = 0;
continue;
}
tok_backup(tok, c);
}
if (!triple || tripcount == 3)
break;
}
else if (c == '\\') {
tripcount = 0;
c = tok_nextc(tok);
if (c == EOF) {
tok->done = E_EOLS;
tok->cur = tok->inp;
return ERRORTOKEN;
}
}
else
tripcount = 0;
}
*p_start = tok->start;
*p_end = tok->cur;
return STRING;
}
/* Line continuation */
if (c == '\\') {
c = tok_nextc(tok);
if (c != '\n') {
tok->done = E_LINECONT;
tok->cur = tok->inp;
return ERRORTOKEN;
}
tok->cont_line = 1;
goto again; /* Read next line */
}
/* Check for two-character token */
{
int c2 = tok_nextc(tok);
int token = PyToken_TwoChars(c, c2);
#ifndef PGEN
if (Py_Py3kWarningFlag && token == NOTEQUAL && c == '<') {
if (PyErr_WarnExplicit(PyExc_DeprecationWarning,
"<> not supported in 3.x; use !=",
tok->filename, tok->lineno,
NULL, NULL)) {
return ERRORTOKEN;
}
}
#endif
if (token != OP) {
int c3 = tok_nextc(tok);
int token3 = PyToken_ThreeChars(c, c2, c3);
if (token3 != OP) {
token = token3;
} else {
tok_backup(tok, c3);
}
*p_start = tok->start;
*p_end = tok->cur;
return token;
}
tok_backup(tok, c2);
}
/* Keep track of parentheses nesting level */
switch (c) {
case '(':
case '[':
case '{':
tok->level++;
break;
case ')':
case ']':
case '}':
tok->level--;
break;
}
/* Punctuation character */
*p_start = tok->start;
*p_end = tok->cur;
return PyToken_OneChar(c);
}
static int
get_common_objects(PyObject *cookie,
const void *key,
size_t nkey,
lcb_error_t err,
pycbc_Connection **conn,
pycbc_Result **res,
int restype,
pycbc_MultiResult **mres)
{
PyObject *hkey;
int rv;
pycbc_assert(Py_TYPE(cookie) == &pycbc_MultiResultType);
*mres = (pycbc_MultiResult*)cookie;
*conn = (*mres)->parent;
if (!(restype & RESTYPE_VARCOUNT)) {
maybe_breakout(*conn);
}
CB_THR_END(*conn);
rv = pycbc_tc_decode_key(*conn, key, nkey, &hkey);
if (rv < 0) {
push_fatal_error(*mres);
return -1;
}
*res = (pycbc_Result*)PyDict_GetItem((PyObject*)*mres, hkey);
if (*res) {
int exists_ok = (restype & RESTYPE_EXISTS_OK) ||
( (*mres)->mropts & PYCBC_MRES_F_UALLOCED);
if (!exists_ok) {
if ((*conn)->flags & PYCBC_CONN_F_WARNEXPLICIT) {
PyErr_WarnExplicit(PyExc_RuntimeWarning,
"Found duplicate key",
__FILE__, __LINE__,
"couchbase._libcouchbase",
NULL);
} else {
PyErr_WarnEx(PyExc_RuntimeWarning,
"Found duplicate key",
1);
}
/**
* We need to destroy the existing object and re-create it.
*/
PyDict_DelItem((PyObject*)*mres, hkey);
*res = NULL;
} else {
Py_XDECREF(hkey);
}
}
if (*res == NULL) {
/**
* Now, get/set the result object
*/
if ( (*mres)->mropts & PYCBC_MRES_F_ITEMS) {
*res = (pycbc_Result*)pycbc_item_new(*conn);
} else if (restype & RESTYPE_BASE) {
*res = (pycbc_Result*)pycbc_result_new(*conn);
} else if (restype & RESTYPE_OPERATION) {
*res = (pycbc_Result*)pycbc_opresult_new(*conn);
} else if (restype & RESTYPE_VALUE) {
*res = (pycbc_Result*)pycbc_valresult_new(*conn);
} else {
abort();
}
PyDict_SetItem((PyObject*)*mres, hkey, (PyObject*)*res);
(*res)->key = hkey;
Py_DECREF(*res);
}
if (err) {
(*res)->rc = err;
}
if (err != LCB_SUCCESS) {
(*mres)->all_ok = 0;
}
return 0;
}
