/* Preferred access to parser is through AST. */
mod_ty
PyParser_ASTFromStringObject(const char *s, PyObject *filename, int start,
PyCompilerFlags *flags, PyArena *arena)
{
mod_ty mod;
PyCompilerFlags localflags;
perrdetail err;
int iflags = PARSER_FLAGS(flags);
node *n = PyParser_ParseStringObject(s, filename,
&_PyParser_Grammar, start, &err,
&iflags);
if (flags == NULL) {
localflags.cf_flags = 0;
flags = &localflags;
}
if (n) {
flags->cf_flags |= iflags & PyCF_MASK;
mod = PyAST_FromNodeObject(n, flags, filename, arena);
PyNode_Free(n);
}
else {
err_input(&err);
mod = NULL;
}
err_free(&err);
return mod;
}
mod_ty
PyParser_ASTFromFileObject(FILE *fp, PyObject *filename, const char* enc,
int start, const char *ps1,
const char *ps2, PyCompilerFlags *flags, int *errcode,
PyArena *arena)
{
mod_ty mod;
PyCompilerFlags localflags;
perrdetail err;
int iflags = PARSER_FLAGS(flags);
node *n = PyParser_ParseFileObject(fp, filename, enc,
&_PyParser_Grammar,
start, ps1, ps2, &err, &iflags);
if (flags == NULL) {
localflags.cf_flags = 0;
flags = &localflags;
}
if (n) {
flags->cf_flags |= iflags & PyCF_MASK;
mod = PyAST_FromNodeObject(n, flags, filename, arena);
PyNode_Free(n);
}
else {
err_input(&err);
if (errcode)
*errcode = err.error;
mod = NULL;
}
err_free(&err);
return mod;
}
RunPythonFileAction::RunPythonFileAction(const ParameterValueMap ¶meters) :
RunPythonAction(parameters)
{
// Converting to boost::filesystem::path first buys us some useful path expansion and validation
const std::string filename(boost::filesystem::path(parameters[PATH]).string());
std::FILE *fp = std::fopen(filename.c_str(), "r");
if (!fp) {
throw SimpleException(M_FILE_MESSAGE_DOMAIN, "Unable to open Python file", strerror(errno));
}
BOOST_SCOPE_EXIT(fp) {
std::fclose(fp);
} BOOST_SCOPE_EXIT_END
ScopedGILAcquire sga;
struct _node *node = PyParser_SimpleParseFile(fp, filename.c_str(), Py_file_input);
BOOST_SCOPE_EXIT(node) {
PyNode_Free(node);
} BOOST_SCOPE_EXIT_END
if (!node ||
!(codeObject = PyNode_Compile(node, filename.c_str())))
{
throw PythonException("Python compilation failed");
}
}
void
PyParser_Delete(parser_state *ps)
{
/* NB If you want to save the parse tree,
you must set p_tree to NULL before calling delparser! */
PyNode_Free(ps->p_tree);
PyMem_FREE(ps);
}
PyObject *
Py_CompileString(char *str, char *filename, int start)
{
node *n;
PyCodeObject *co;
n = PyParser_SimpleParseString(str, start);
if (n == NULL)
return NULL;
co = PyNode_Compile(n, filename);
PyNode_Free(n);
return (PyObject *)co;
}
static PyObject *
run_node(node *n, char *filename, PyObject *globals, PyObject *locals)
{
PyCodeObject *co;
PyObject *v;
co = PyNode_Compile(n, filename);
PyNode_Free(n);
if (co == NULL)
return NULL;
v = PyEval_EvalCode(co, globals, locals);
Py_DECREF(co);
return v;
}
/* parser_newstobject(node* st)
*
* Allocates a new Python object representing an ST. This is simply the
* 'wrapper' object that holds a node* and allows it to be passed around in
* Python code.
*
*/
static PyObject*
parser_newstobject(node *st, int type)
{
PyST_Object* o = PyObject_New(PyST_Object, &PyST_Type);
if (o != 0) {
o->st_node = st;
o->st_type = type;
o->st_flags.cf_flags = 0;
}
else {
PyNode_Free(st);
}
return ((PyObject*)o);
}
grammar *
getgrammar(char *filename)
{
FILE *fp;
node *n;
grammar *g0, *g;
perrdetail err;
fp = fopen(filename, "r");
if (fp == NULL) {
perror(filename);
Py_Exit(1);
}
g0 = meta_grammar();
n = PyParser_ParseFile(fp, filename, g0, g0->g_start,
(char *)NULL, (char *)NULL, &err);
fclose(fp);
if (n == NULL) {
fprintf(stderr, "Parsing error %d, line %d.\n",
err.error, err.lineno);
if (err.text != NULL) {
size_t len;
int i;
fprintf(stderr, "%s", err.text);
len = strlen(err.text);
if (len == 0 || err.text[len-1] != '\n')
fprintf(stderr, "\n");
for (i = 0; i < err.offset; i++) {
if (err.text[i] == '\t')
putc('\t', stderr);
else
putc(' ', stderr);
}
fprintf(stderr, "^\n");
PyObject_FREE(err.text);
}
Py_Exit(1);
}
g = pgen(n);
PyNode_Free(n);
if (g == NULL) {
printf("Bad grammar.\n");
Py_Exit(1);
}
return g;
}
/* Preferred access to parser is through AST. */
mod_ty
PyParser_ASTFromString(const char *s, const char *filename, int start,
PyCompilerFlags *flags, PyArena *arena)
{
mod_ty mod;
perrdetail err;
node *n = PyParser_ParseStringFlagsFilename(s, filename,
&_PyParser_Grammar, start, &err,
PARSER_FLAGS(flags));
if (n) {
mod = PyAST_FromNode(n, flags, filename, arena);
PyNode_Free(n);
return mod;
}
else {
err_input(&err);
return NULL;
}
}
int
csl_compile(char *str, char *name, char **codeptr, size_t *sizeptr)
{
PyObject *pCode, *pStr;
node *n;
size_t size;
// compile into a code object
n = PyParser_SimpleParseString(str, Py_file_input);
if (!n) {
log_exception();
return CSL_BADCODE;
}
pCode = (PyObject *) PyNode_Compile(n, name);
PyNode_Free(n);
if (!pCode) {
log_exception();
return CSL_BADCODE;
}
// serialize code object
#if PY_MINOR_VERSION == 3
pStr = PyMarshal_WriteObjectToString(pCode);
#else
pStr = PyMarshal_WriteObjectToString(pCode, 0);
#endif
Py_DECREF(pCode);
if (!pStr) {
return CSL_NOMEM;
}
size = PyString_Size(pStr);
*codeptr = malloc(size);
if (!*codeptr) {
Py_DECREF(pStr);
return CSL_NOMEM;
}
memcpy(*codeptr, PyString_AsString(pStr), size);
*sizeptr = size;
Py_DECREF(pStr);
return 0;
}
mod_ty
PyParser_ASTFromFile(FILE *fp, const char *filename, int start, char *ps1,
char *ps2, PyCompilerFlags *flags, int *errcode,
PyArena *arena)
{
mod_ty mod;
perrdetail err;
node *n = PyParser_ParseFileFlags(fp, filename, &_PyParser_Grammar,
start, ps1, ps2, &err, PARSER_FLAGS(flags));
if (n) {
mod = PyAST_FromNode(n, flags, filename, arena);
PyNode_Free(n);
return mod;
}
else {
err_input(&err);
if (errcode)
*errcode = err.error;
return NULL;
}
}
int
csl_execute(char *code, size_t size, const char *func_name, struct pack *pak, char **resptr, int *reslen)
{
PyObject *pCode, *pModule, *pDict, *pFunc, *pValue, *pStr;
PyObject *pArgs, *pkArgs;
PyMethodDef *meth;
node *n;
pModule = PyImport_AddModule("__builtin__");
pDict = PyModule_GetDict(pModule);
for (meth = methods; meth->ml_name; meth++) {
pCode = PyCFunction_New(meth, NULL);
PyDict_SetItemString(pDict, meth->ml_name, pCode);
}
if (size == 0) {
n = PyParser_SimpleParseString(code, Py_file_input);
if (!n) {
log_exception();
return CSL_BADCODE;
}
pCode = (PyObject *) PyNode_Compile(n, "lala");
PyNode_Free(n);
if (!pCode) {
log_exception();
return CSL_BADCODE;
}
} else {
pCode = PyMarshal_ReadObjectFromString(code, size);
if (!pCode) {
log_exception();
return CSL_BADCODE;
}
}
pModule = PyImport_ExecCodeModule("csl", pCode);
Py_DECREF(pCode);
if (!pModule || !PyModule_Check(pModule)) {
return CSL_BADCODE;
}
pDict = PyModule_GetDict(pModule);
if (!pDict) {
Py_DECREF(pModule);
return CSL_BADCODE;
}
pFunc = PyDict_GetItemString(pDict, func_name);
if (!pFunc || !PyCallable_Check(pFunc)) {
Py_DECREF(pModule);
return CSL_NOFUNC;
}
pArgs = NULL;
pkArgs = PyDict_New();
while (pak) {
PyObject *p;
char *t, *t2;
size_t sz;
if (pack_get(pak, &t, &sz) == 0) break;
if (pack_get(pak, &t2, &sz) == 0) {
pArgs = PyTuple_New(1);
PyTuple_SetItem(pArgs, 0, PyString_FromString(t));
Py_DECREF(pkArgs);
break;
}
p = PyString_FromStringAndSize(t2, sz);
PyDict_SetItemString(pkArgs, t, p);
}
if (!pArgs) pArgs = PyTuple_New(0);
pValue = PyObject_Call(pFunc, pArgs, pkArgs);
if (!pValue) {
log_exception();
Py_DECREF(pModule);
return CSL_FUNCERR;
}
pStr = PyObject_Str(pValue);
Py_DECREF(pValue);
Py_DECREF(pModule);
// is return value asked?
if (resptr == NULL) return 0;
*reslen = PyString_Size(pStr);
*resptr = malloc((*reslen) + 1);
if (!*resptr) {
Py_DECREF(pStr);
return CSL_NOMEM;
}
memcpy(*resptr, PyString_AsString(pStr), *reslen);
(*resptr)[*reslen] = '\0';
return 0;
}
static node *
parsetok(struct tok_state *tok, grammar *g, int start, perrdetail *err_ret,
int *flags)
{
parser_state *ps;
node *n;
int started = 0;
if ((ps = PyParser_New(g, start)) == NULL) {
err_ret->error = E_NOMEM;
PyTokenizer_Free(tok);
return NULL;
}
#ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD
if (*flags & PyPARSE_BARRY_AS_BDFL)
ps->p_flags |= CO_FUTURE_BARRY_AS_BDFL;
#endif
for (;;) {
char *a, *b;
int type;
size_t len;
char *str;
int col_offset;
type = PyTokenizer_Get(tok, &a, &b);
if (type == ERRORTOKEN) {
err_ret->error = tok->done;
break;
}
if (type == ENDMARKER && started) {
type = NEWLINE; /* Add an extra newline */
started = 0;
/* Add the right number of dedent tokens,
except if a certain flag is given --
codeop.py uses this. */
if (tok->indent &&
!(*flags & PyPARSE_DONT_IMPLY_DEDENT))
{
tok->pendin = -tok->indent;
tok->indent = 0;
}
}
else
started = 1;
len = b - a; /* XXX this may compute NULL - NULL */
str = (char *) PyObject_MALLOC(len + 1);
if (str == NULL) {
err_ret->error = E_NOMEM;
break;
}
if (len > 0)
strncpy(str, a, len);
str[len] = '\0';
#ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD
if (type == NOTEQUAL) {
if (!(ps->p_flags & CO_FUTURE_BARRY_AS_BDFL) &&
strcmp(str, "!=")) {
PyObject_FREE(str);
err_ret->error = E_SYNTAX;
break;
}
else if ((ps->p_flags & CO_FUTURE_BARRY_AS_BDFL) &&
strcmp(str, "<>")) {
PyObject_FREE(str);
err_ret->text = "with Barry as BDFL, use '<>' "
"instead of '!='";
err_ret->error = E_SYNTAX;
break;
}
}
#endif
if (a >= tok->line_start)
col_offset = a - tok->line_start;
else
col_offset = -1;
if ((err_ret->error =
PyParser_AddToken(ps, (int)type, str,
tok->lineno, col_offset,
&(err_ret->expected))) != E_OK) {
if (err_ret->error != E_DONE) {
PyObject_FREE(str);
err_ret->token = type;
}
break;
}
}
if (err_ret->error == E_DONE) {
n = ps->p_tree;
ps->p_tree = NULL;
#ifndef PGEN
/* Check that the source for a single input statement really
is a single statement by looking at what is left in the
buffer after parsing. Trailing whitespace and comments
are OK. */
if (start == single_input) {
char *cur = tok->cur;
char c = *tok->cur;
for (;;) {
while (c == ' ' || c == '\t' || c == '\n' || c == '\014')
c = *++cur;
if (!c)
break;
if (c != '#') {
err_ret->error = E_BADSINGLE;
PyNode_Free(n);
n = NULL;
break;
}
/* Suck up comment. */
while (c && c != '\n')
c = *++cur;
}
}
#endif
}
else
n = NULL;
#ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD
*flags = ps->p_flags;
#endif
PyParser_Delete(ps);
if (n == NULL) {
if (tok->done == E_EOF)
err_ret->error = E_EOF;
err_ret->lineno = tok->lineno;
if (tok->buf != NULL) {
size_t len;
assert(tok->cur - tok->buf < INT_MAX);
err_ret->offset = (int)(tok->cur - tok->buf);
len = tok->inp - tok->buf;
err_ret->text = (char *) PyObject_MALLOC(len + 1);
if (err_ret->text != NULL) {
if (len > 0)
strncpy(err_ret->text, tok->buf, len);
err_ret->text[len] = '\0';
}
}
} else if (tok->encoding != NULL) {
/* 'nodes->n_str' uses PyObject_*, while 'tok->encoding' was
* allocated using PyMem_
*/
node* r = PyNode_New(encoding_decl);
if (r)
r->n_str = PyObject_MALLOC(strlen(tok->encoding)+1);
if (!r || !r->n_str) {
err_ret->error = E_NOMEM;
if (r)
PyObject_FREE(r);
n = NULL;
goto done;
}
strcpy(r->n_str, tok->encoding);
PyMem_FREE(tok->encoding);
tok->encoding = NULL;
r->n_nchildren = 1;
r->n_child = n;
n = r;
}
done:
PyTokenizer_Free(tok);
return n;
}
static int py_shell_execute(MYX_GRT *grt, const char *linebuf)
{
node *n;
MYX_GRT_SHELL_PRIVATE *pshell= grt->shell->data;
PyObject *result;
PyObject *mainmod;
PyObject *globals;
if (pshell->current_line)
pshell->current_line= str_g_append(pshell->current_line, linebuf);
else
pshell->current_line= g_strdup(linebuf);
myx_py_acquire(pshell->pycon);
n= PyParser_SimpleParseStringFlags(pshell->current_line,
Py_single_input,
0);
if (n && (*linebuf==' ' || *linebuf=='\t'))
{
myx_py_release(pshell->pycon);
return 1;
}
if (!n && PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_SyntaxError))
{
PyObject *excep;
PyObject *value;
PyObject *message;
PyObject *trace;
PyErr_Fetch(&excep, &value, &trace);
Py_DECREF(excep);
if (trace)
{
Py_DECREF(trace);
}
message= PyTuple_GetItem(value, 0);
if (strstr(PyString_AsString(message), "unexpected EOF") ||
strncmp(PyString_AsString(message), "EOF", 3)==0)
{
Py_DECREF(value);
PyErr_Clear();
myx_py_release(pshell->pycon);
return 1;
}
Py_DECREF(value);
}
if (!n)
{
PyErr_Print();
g_free(pshell->current_line);
pshell->current_line= NULL;
PyErr_Clear();
myx_py_release(pshell->pycon);
return -1;
}
PyNode_Free(n);
PyErr_Clear();
// command is supposedly complete, try to execute it
mainmod= PyImport_AddModule("__main__");
if (!mainmod)
{
myx_py_release(pshell->pycon);
return -1;
}
globals= PyModule_GetDict(mainmod);
result= PyRun_String(pshell->current_line, Py_single_input, globals, globals);
g_free(pshell->current_line);
pshell->current_line= NULL;
if (!result)
{
//XXX use myx_grt_prnt to print the exc
if (PyErr_Occurred())
PyErr_Print();
myx_py_release(pshell->pycon);
return -1;
}
else
{
#if notworking
// attempt to show the result object
if (result != Py_None)
{
PyObject *tmp= PyObject_Str(result);
if (!tmp)
{
PyErr_Clear();
}
else
{
myx_grt_printf(grt, "%s\n", PyString_AsString(tmp));
}
if (tmp)
Py_DECREF(tmp);
}
#endif
Py_DECREF(result);
}
myx_py_release(pshell->pycon);
return 0;
}
/* void parser_free(PyST_Object* st)
*
* This is called by a del statement that reduces the reference count to 0.
*
*/
static void
parser_free(PyST_Object *st)
{
PyNode_Free(st->st_node);
PyObject_Del(st);
}
