AppPkg/Applications/Python/Python-2.7.10/Python/future.c

   1 #include "Python.h"
   2 #include "Python-ast.h"
   3 #include "node.h"
   4 #include "token.h"
   5 #include "graminit.h"
   6 #include "code.h"
   7 #include "compile.h"
   8 #include "symtable.h"
   9
  10 #define UNDEFINED_FUTURE_FEATURE "future feature %.100s is not defined"
  11 #define ERR_LATE_FUTURE \
  12 "from __future__ imports must occur at the beginning of the file"
  13
  14 static int
  15 future_check_features(PyFutureFeatures *ff, stmt_ty s, const char *filename)
  16 {
  17     int i;
  18     asdl_seq *names;
  19
  20     assert(s->kind == ImportFrom_kind);
  21
  22     names = s->v.ImportFrom.names;
  23     for (i = 0; i < asdl_seq_LEN(names); i++) {
  24         alias_ty name = (alias_ty)asdl_seq_GET(names, i);
  25         const char *feature = PyString_AsString(name->name);
  26         if (!feature)
  27             return 0;
  28         if (strcmp(feature, FUTURE_NESTED_SCOPES) == 0) {
  29             continue;
  30         } else if (strcmp(feature, FUTURE_GENERATORS) == 0) {
  31             continue;
  32         } else if (strcmp(feature, FUTURE_DIVISION) == 0) {
  33             ff->ff_features |= CO_FUTURE_DIVISION;
  34         } else if (strcmp(feature, FUTURE_ABSOLUTE_IMPORT) == 0) {
  35             ff->ff_features |= CO_FUTURE_ABSOLUTE_IMPORT;
  36         } else if (strcmp(feature, FUTURE_WITH_STATEMENT) == 0) {
  37             ff->ff_features |= CO_FUTURE_WITH_STATEMENT;
  38         } else if (strcmp(feature, FUTURE_PRINT_FUNCTION) == 0) {
  39             ff->ff_features |= CO_FUTURE_PRINT_FUNCTION;
  40         } else if (strcmp(feature, FUTURE_UNICODE_LITERALS) == 0) {
  41             ff->ff_features |= CO_FUTURE_UNICODE_LITERALS;
  42         } else if (strcmp(feature, "braces") == 0) {
  43             PyErr_SetString(PyExc_SyntaxError,
  44                             "not a chance");
  45             PyErr_SyntaxLocation(filename, s->lineno);
  46             return 0;
  47         } else {
  48             PyErr_Format(PyExc_SyntaxError,
  49                          UNDEFINED_FUTURE_FEATURE, feature);
  50             PyErr_SyntaxLocation(filename, s->lineno);
  51             return 0;
  52         }
  53     }
  54     return 1;
  55 }
  56
  57 static int
  58 future_parse(PyFutureFeatures *ff, mod_ty mod, const char *filename)
  59 {
  60     int i, found_docstring = 0, done = 0, prev_line = 0;
  61
  62     if (!(mod->kind == Module_kind || mod->kind == Interactive_kind))
  63         return 1;
  64
  65     /* A subsequent pass will detect future imports that don't
  66        appear at the beginning of the file.  There's one case,
  67        however, that is easier to handle here: A series of imports
  68        joined by semi-colons, where the first import is a future
  69        statement but some subsequent import has the future form
  70        but is preceded by a regular import.
  71     */
  72
  73
  74     for (i = 0; i < asdl_seq_LEN(mod->v.Module.body); i++) {
  75         stmt_ty s = (stmt_ty)asdl_seq_GET(mod->v.Module.body, i);
  76
  77         if (done && s->lineno > prev_line)
  78             return 1;
  79         prev_line = s->lineno;
  80
  81         /* The tests below will return from this function unless it is
  82            still possible to find a future statement.  The only things
  83            that can precede a future statement are another future
  84            statement and a doc string.
  85         */
  86
  87         if (s->kind == ImportFrom_kind) {
  88             identifier modname = s->v.ImportFrom.module;
  89             if (modname && PyString_GET_SIZE(modname) == 10 &&
  90                 !strcmp(PyString_AS_STRING(modname), "__future__")) {
  91                 if (done) {
  92                     PyErr_SetString(PyExc_SyntaxError,
  93                                     ERR_LATE_FUTURE);
  94                     PyErr_SyntaxLocation(filename,
  95                                          s->lineno);
  96                     return 0;
  97                 }
  98                 if (!future_check_features(ff, s, filename))
  99                     return 0;
 100                 ff->ff_lineno = s->lineno;
 101             }
 102             else
 103                 done = 1;
 104         }
 105         else if (s->kind == Expr_kind && !found_docstring) {
 106             expr_ty e = s->v.Expr.value;
 107             if (e->kind != Str_kind)
 108                 done = 1;
 109             else
 110                 found_docstring = 1;
 111         }
 112         else
 113             done = 1;
 114     }
 115     return 1;
 116 }
 117
 118
 119 PyFutureFeatures *
 120 PyFuture_FromAST(mod_ty mod, const char *filename)
 121 {
 122     PyFutureFeatures *ff;
 123
 124     ff = (PyFutureFeatures *)PyObject_Malloc(sizeof(PyFutureFeatures));
 125     if (ff == NULL) {
 126         PyErr_NoMemory();
 127         return NULL;
 128     }
 129     ff->ff_features = 0;
 130     ff->ff_lineno = -1;
 131
 132     if (!future_parse(ff, mod, filename)) {
 133         PyObject_Free(ff);
 134         return NULL;
 135     }
 136     return ff;
 137 }