idlpython.cc

来自「编译工具」· CC 代码 · 共 1,666 行 · 第 1/3 页

			commentsToList(b->comments()),
			b->identifier(),
			scopedNameToList(b->scopedName()),
			b->repoId(),
			pyboxedType, (int)b->constrType());
  ASSERT_RESULT;
  registerPyDecl(b->scopedName(), result_);
}

void
PythonVisitor::
visitValueAbs(ValueAbs* a)
{
  int       l;
  PyObject* pyobj;
  Decl*     d;

  // Inherited values and interfaces
  InheritSpec*      inh;
  ValueInheritSpec* vinh;

  for (l=0, vinh = a->inherits(); vinh; vinh = vinh->next(), ++l);
  PyObject* pyinherits = PyList_New(l);

  for (l=0, vinh = a->inherits(); vinh; vinh = vinh->next(), ++l) {
    d = vinh->decl();
    if (d->kind() == Decl::D_VALUEABS)
      pyobj = findPyDecl(((ValueAbs*)d)->scopedName());
    else if (d->kind() == Decl::D_DECLARATOR)
      pyobj = findPyDecl(((Declarator*)d)->scopedName());
    else
      assert(0);
    PyList_SetItem(pyinherits, l, pyobj);
  }
  for (l=0, inh = a->supports(); inh; inh = inh->next(), ++l);
  PyObject* pysupports = PyList_New(l);

  for (l=0, inh = a->supports(); inh; inh = inh->next(), ++l) {
    d = inh->decl();
    if (d->kind() == Decl::D_INTERFACE)
      pyobj = findPyDecl(((Interface*)d)->scopedName());
    else if (d->kind() == Decl::D_DECLARATOR)
      pyobj = findPyDecl(((Declarator*)d)->scopedName());
    else
      assert(0);
    PyList_SetItem(pysupports, l, pyobj);
  }

  PyObject* pyvalue =
    PyObject_CallMethod(idlast_, (char*)"ValueAbs", (char*)"siiNNsNsNN",
			a->file(), a->line(), (int)a->mainFile(),
			pragmasToList(a->pragmas()),
			commentsToList(a->comments()),
			a->identifier(),
			scopedNameToList(a->scopedName()),
			a->repoId(),
			pyinherits, pysupports);
  ASSERT_PYOBJ(pyvalue);
  registerPyDecl(a->scopedName(), pyvalue);

  // Contents
  for (l=0, d = a->contents(); d; d = d->next(), ++l);
  PyObject* pycontents = PyList_New(l);

  for (l=0, d = a->contents(); d; d = d->next(), ++l) {
    d->accept(*this);
    PyList_SetItem(pycontents, l, result_);
  }
  PyObject* r = PyObject_CallMethod(pyvalue, (char*)"_setContents",
				    (char*)"N", pycontents);
  ASSERT_PYOBJ(r); Py_DECREF(r);
  result_ = pyvalue;
}

void
PythonVisitor::
visitValue(Value* v)
{
  int       l;
  PyObject* pyobj;
  Decl*     d;

  // Inherited values and interfaces
  InheritSpec*      inh;
  ValueInheritSpec* vinh;
  int               truncatable = 0;

  if (v->inherits()) truncatable = v->inherits()->truncatable();

  for (l=0, vinh = v->inherits(); vinh; vinh = vinh->next(), ++l);
  PyObject* pyinherits = PyList_New(l);

  for (l=0, vinh = v->inherits(); vinh; vinh = vinh->next(), ++l) {
    d = vinh->decl();
    if (d->kind() == Decl::D_VALUE)
      pyobj = findPyDecl(((Value*)d)->scopedName());
    else if (d->kind() == Decl::D_VALUEABS)
      pyobj = findPyDecl(((ValueAbs*)d)->scopedName());
    else if (d->kind() == Decl::D_DECLARATOR)
      pyobj = findPyDecl(((Declarator*)d)->scopedName());
    else
      assert(0);
    PyList_SetItem(pyinherits, l, pyobj);
  }
  for (l=0, inh = v->supports(); inh; inh = inh->next(), ++l);
  PyObject* pysupports = PyList_New(l);

  for (l=0, inh = v->supports(); inh; inh = inh->next(), ++l) {
    d = inh->decl();
    if (d->kind() == Decl::D_INTERFACE)
      pyobj = findPyDecl(((Interface*)d)->scopedName());
    else if (d->kind() == Decl::D_DECLARATOR)
      pyobj = findPyDecl(((Declarator*)d)->scopedName());
    else
      assert(0);
    PyList_SetItem(pysupports, l, pyobj);
  }

  PyObject* pyvalue =
    PyObject_CallMethod(idlast_, (char*)"Value", (char*)"siiNNsNsiNiN",
			v->file(), v->line(), (int)v->mainFile(),
			pragmasToList(v->pragmas()),
			commentsToList(v->comments()),
			v->identifier(),
			scopedNameToList(v->scopedName()),
			v->repoId(),
			(int)v->custom(), pyinherits,
			truncatable, pysupports);
  ASSERT_PYOBJ(pyvalue);
  registerPyDecl(v->scopedName(), pyvalue);

  // Contents
  for (l=0, d = v->contents(); d; d = d->next(), ++l);
  PyObject* pycontents = PyList_New(l);

  for (l=0, d = v->contents(); d; d = d->next(), ++l) {
    d->accept(*this);
    PyList_SetItem(pycontents, l, result_);
  }
  PyObject* r = PyObject_CallMethod(pyvalue, (char*)"_setContents",
				    (char*)"N", pycontents);
  ASSERT_PYOBJ(r); Py_DECREF(r);
  result_ = pyvalue;
}

// Types

void
PythonVisitor::
visitBaseType(BaseType* t)
{
  result_ = PyObject_CallMethod(idltype_, (char*)"baseType", (char*)"i",
				(int)t->kind());
  ASSERT_RESULT;
}

void
PythonVisitor::
visitStringType(StringType* t)
{
  result_ = PyObject_CallMethod(idltype_, (char*)"stringType",
				(char*)"i", t->bound());
  ASSERT_RESULT;
}

void
PythonVisitor::
visitWStringType(WStringType* t)
{
  result_ = PyObject_CallMethod(idltype_, (char*)"wstringType",
				(char*)"i", t->bound());
  ASSERT_RESULT;
}

void
PythonVisitor::
visitSequenceType(SequenceType* t)
{
  t->seqType()->accept(*this);
  result_ = PyObject_CallMethod(idltype_, (char*)"sequenceType", (char*)"Nii",
				result_, t->bound(), (int)t->local());
  ASSERT_RESULT;
}

void
PythonVisitor::
visitFixedType(FixedType* t)
{
  result_ = PyObject_CallMethod(idltype_, (char*)"fixedType", (char*)"ii",
				t->digits(), t->scale());
  ASSERT_RESULT;
}

void
PythonVisitor::
visitDeclaredType(DeclaredType* t)
{
  if (t->decl()) {
    result_ =
      PyObject_CallMethod(idltype_, (char*)"declaredType", (char*)"NNii",
			  findPyDecl(t->declRepoId()->scopedName()),
			  scopedNameToList(t->declRepoId()->scopedName()),
			  (int)t->kind(), (int)t->local());
  }
  else {
    if (t->kind() == IdlType::tk_objref) {
      PyObject* pysn   = Py_BuildValue((char*)"[ss]", (char*)"CORBA",
				       (char*)"Object");

      PyObject* pydecl = PyObject_CallMethod(idlast_, (char*)"findDecl",
					     (char*)"O", pysn);

      result_          = PyObject_CallMethod(idltype_, (char*)"declaredType",
					     (char*)"NNii", pydecl, pysn,
					     (int)t->kind(), (int)t->local());
    }
    else if (t->kind() == IdlType::tk_value) {
      PyObject* pysn   = Py_BuildValue((char*)"[ss]", (char*)"CORBA",
				       (char*)"ValueBase");

      PyObject* pydecl = PyObject_CallMethod(idlast_, (char*)"findDecl",
					     (char*)"O", pysn);

      result_          = PyObject_CallMethod(idltype_, (char*)"declaredType",
					     (char*)"NNii", pydecl, pysn,
					     (int)t->kind(), (int)t->local());
    }
    else abort();
  }
  ASSERT_RESULT;
}

extern "C" {
  static PyObject* IdlPyCompile(PyObject* self, PyObject* args)
  {
    PyObject*   arg;
    const char* name;
    FILE*       file;
    IDL_Boolean to_close = 0;

    if (!PyArg_ParseTuple(args, (char*)"O", &arg))
      return 0;

    if (PyString_Check(arg)) {
      name = PyString_AsString(arg);
      file = fopen(name, "r");
      if (!file) {
	PyErr_SetString(PyExc_IOError,
			(char*)"Cannot open file");
	return 0;
      }
      to_close = 1;
    }
    else if (PyFile_Check(arg)) {
      PyObject* pyname = PyFile_Name(arg);
      file = PyFile_AsFile(arg);
      name = PyString_AsString(pyname);
    }
    else {
      PyErr_SetString(PyExc_TypeError,
		      (char*)"Argument must be a file or filename");
      return 0;
    }

    IDL_Boolean success = AST::process(file, name);

    if (to_close)
      fclose(file);

    if (success) {
      PythonVisitor v;
      AST::tree()->accept(v);
      return v.result();
    }
    else {
      AST::clear();
      Py_INCREF(Py_None);
      return Py_None;
    }
  }

  static PyObject* IdlPyClear(PyObject* self, PyObject* args)
  {
    if (!PyArg_ParseTuple(args, (char*)""))
      return 0;

    AST::clear();
    Py_INCREF(Py_None);
    return Py_None;
  }

  static PyObject* IdlPyDump(PyObject* self, PyObject* args)
  {
    PyObject*   arg;
    const char* name;
    FILE*       file;
    IDL_Boolean to_close = 0;

    if (!PyArg_ParseTuple(args, (char*)"O", &arg))
      return 0;

    if (PyString_Check(arg)) {
      name = PyString_AsString(arg);
      file = fopen(name, "r");
      if (!file) {
	PyErr_SetString(PyExc_IOError,
			(char*)"Cannot open file");
	return 0;
      }
      to_close = 1;
    }
    else if (PyFile_Check(arg)) {
      PyObject* pyname = PyFile_Name(arg);
      file = PyFile_AsFile(arg);
      name = PyString_AsString(pyname);
    }
    else {
      PyErr_SetString(PyExc_TypeError,
		      (char*)"Argument must be a file or filename");
      return 0;
    }

    IDL_Boolean success = AST::process(file, name);

    if (to_close)
      fclose(file);

    if (success) {
      DumpVisitor v;
      AST::tree()->accept(v);
    }
    AST::clear();

    Py_INCREF(Py_None);
    return Py_None;
  }

  static PyObject* IdlPyQuiet(PyObject* self, PyObject* args)
  {
    if (!PyArg_ParseTuple(args, (char*)"")) return 0;
    Config::quiet = 1;
    Py_INCREF(Py_None); return Py_None;
  }

  static PyObject* IdlPyNoForwardWarning(PyObject* self, PyObject* args)
  {
    if (!PyArg_ParseTuple(args, (char*)"")) return 0;
    Config::forwardWarning = 0;
    Py_INCREF(Py_None); return Py_None;
  }

  static PyObject* IdlPyKeepComments(PyObject* self, PyObject* args)
  {
    int first;
    if (!PyArg_ParseTuple(args, (char*)"i", &first)) return 0;
    Config::keepComments  = 1;
    Config::commentsFirst = first;
    Py_INCREF(Py_None); return Py_None;
  }

  static PyObject* IdlPyRelativeScopedName(PyObject* self, PyObject* args)
  {
    PyObject *pyfrom, *pyto;
    if (!PyArg_ParseTuple(args, (char*)"OO", &pyfrom, &pyto)) return 0;

    if (!PySequence_Check(pyfrom) || !PySequence_Check(pyto)) {
      PyErr_SetString(PyExc_TypeError,
		      (char*)"Both arguments must be sequences of strings");
      return 0;
    }

    if (PyObject_Length(pyto) == 0) {
      PyErr_SetString(PyExc_TypeError,
		      (char*)"Argument 2 must be a non-empty sequence");
      return 0;
    }

    ScopedName* from = 0;
    ScopedName* to   = 0;

    int i;
    // Convert lists to absolute ScopedNames
    for (i=0; i < PyObject_Length(pyfrom); i++) {
      PyObject* tmp = PySequence_GetItem(pyfrom, i);

      if (!PyString_Check(tmp)) {
	if (from) delete from;
	PyErr_SetString(PyExc_TypeError,
			(char*)"Both arguments must be sequences of strings");
	return 0;
      }
      if (from)
	from->append(PyString_AsString(tmp));
      else
	from = new ScopedName(PyString_AsString(tmp), 1);
    }

    for (i=0; i < PyObject_Length(pyto); i++) {
      PyObject* tmp = PySequence_GetItem(pyto, i);

      if (!PyString_Check(tmp)) {
	if (from) delete from;
	if (to)   delete to;
	PyErr_SetString(PyExc_TypeError,
			(char*)"Both arguments must be sequences of strings");
	return 0;
      }
      if (to)
	to->append(PyString_AsString(tmp));
      else
	to = new ScopedName(PyString_AsString(tmp), 1);
    }

    ScopedName* result = Scope::relativeScopedName(from, to);

    if (from) delete from;
    delete to;

    if (result) {
      PyObject* pyresult = PythonVisitor::scopedNameToList(result);
      if (result->absolute())
	PyList_Insert(pyresult, 0, Py_None);
      delete result;
      return pyresult;
    }
    Py_INCREF(Py_None);
    return Py_None;
  }

  static PyObject* IdlPyRunInteractiveLoop(PyObject* self, PyObject* args)
  {
    PyRun_InteractiveLoop(stdin, (char*)"<stdin>");
    Py_INCREF(Py_None);
    return Py_None;
  }

  static PyObject* IdlPyCaseSensitive(PyObject* self, PyObject* args)
  {
    if (!PyArg_ParseTuple(args, (char*)"")) return 0;
    Config::caseSensitive = 1;
    Py_INCREF(Py_None); return Py_None;
  }

  static PyObject* IdlPyPlatformDefines(PyObject* self, PyObject* args)
  {
    if (!PyArg_ParseTuple(args, (char*)"")) return 0;
    PyObject* l = PyList_New(0);
#ifdef HAS_LongLong
    PyList_Append(l, PyString_FromString("-DHAS_LongLong"));
#endif
#ifdef HAS_LongDouble
    PyList_Append(l, PyString_FromString("-DHAS_LongDouble"));
#endif
    return l;
  }

  static PyObject* IdlPyAlwaysTempFile(PyObject* self, PyObject* args)
  {
    if (!PyArg_ParseTuple(args, (char*)"")) return 0;
#if defined (_MSC_VER) && _MSC_VER > 1200 || defined(__DMC__)
    return PyInt_FromLong(1);
#else
    return PyInt_FromLong(0);
#endif
  }

  static PyMethodDef omniidl_methods[] = {
    {(char*)"compile",            IdlPyCompile,            METH_VARARGS},
    {(char*)"clear",              IdlPyClear,              METH_VARARGS},
    {(char*)"dump",               IdlPyDump,               METH_VARARGS},
    {(char*)"quiet",              IdlPyQuiet,              METH_VARARGS},
    {(char*)"noForwardWarning",   IdlPyNoForwardWarning,   METH_VARARGS},
    {(char*)"keepComments",       IdlPyKeepComments,       METH_VARARGS},
    {(char*)"relativeScopedName", IdlPyRelativeScopedName, METH_VARARGS},
    {(char*)"runInteractiveLoop", IdlPyRunInteractiveLoop, METH_VARARGS},
    {(char*)"caseSensitive",      IdlPyCaseSensitive,      METH_VARARGS},
    {(char*)"platformDefines",    IdlPyPlatformDefines,    METH_VARARGS},
    {(char*)"alwaysTempFile",     IdlPyAlwaysTempFile,     METH_VARARGS},
    {NULL, NULL}
  };

  void DLL_EXPORT init_omniidl()
  {
    PyObject* m = Py_InitModule((char*)"_omniidl", omniidl_methods);
    PyObject_SetAttrString(m, (char*)"version",
			   PyString_FromString(IDLMODULE_VERSION));
  }
}

#ifdef OMNIIDL_EXECUTABLE

// It's awkward to make a command named 'omniidl' on NT which runs
// Python, so we make the front-end a Python executable which always
// runs omniidl.main.
#ifdef __VMS
#ifdef PYTHON_1
extern "C" int PyVMS_init(int* pvi_argc, char*** pvi_argv);
#endif
#endif

int
main(int argc, char** argv)
{
  const char* omniidl_string =
"import sys, os, os.path, string\n"
"\n"
"pylibdir   = None\n"
"binarchdir = os.path.abspath(os.path.dirname(sys.executable))\n"
"\n"
"if binarchdir != '':\n"
"    sys.path.insert(0, binarchdir)\n"
"    bindir, archname = os.path.split(binarchdir)\n"
"    treedir, bin     = os.path.split(bindir)\n"
"    if string.lower(bin) == 'bin':\n"
"        pylibdir = os.path.join(treedir, 'lib', 'python')\n"
"\n"
"        if os.path.isdir(pylibdir):\n"
"            sys.path.insert(0, pylibdir)\n"
"else:\n"
"    print '''can't parse %s's path name!''' % sys.executable\n"
"\n"
"try:\n"
"    import omniidl.main\n"
"except ImportError, msg:\n"
"    sys.stderr.write('\\n\\n')\n"
"    sys.stderr.write('omniidl: ERROR!\\n\\n')\n"
"    sys.stderr.write('omniidl: Could not open Python files for IDL compiler\\n')\n"
"    sys.stderr.write('omniidl: Please put them in directory ' + \\\n"
"                     (pylibdir or binarchdir) + '\\n')\n"
"    sys.stderr.write('omniidl: (or set the PYTHONPATH environment variable)\\n')\n"
"    sys.stderr.write('\\n')\n"
"    sys.stderr.write('omniidl: (The error was \\'' + str(msg) + '\\')\\n')\n"
"    sys.stderr.write('\\n\\n')\n"
"    sys.stderr.flush()\n"
"    sys.exit(1)\n"
"\n"
"omniidl.main.main()\n";

#ifdef __VMS
#ifdef PYTHON_1
  PyVMS_init(&argc, &argv);
#endif
  Py_SetProgramName(argv[0]);
#endif
  Py_Initialize();
  PySys_SetArgv(argc, argv);

  init_omniidl();

  return PyRun_SimpleString((char*)omniidl_string);
}

#endif