/* 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); }