reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Derived Classes

  406 template <class T> class TypedPythonObject : public PythonObject {

Declarations

   64 class PythonObject;

References

79566     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name, dict);
79571     PythonObject frame_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_frame));
79572     PythonObject bp_loc_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_bp_loc));
79574     PythonObject result;
79581         PythonObject args_arg(PyRefType::Owned, SBTypeToSWIGWrapper(args_value));
79613     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name, dict);
79618     PythonObject frame_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_frame));
79619     PythonObject wp_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_wp));
79620     PythonObject result = pfunc(frame_arg, wp_arg, dict);
79671         pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name, dict);
79682     PythonObject result;
79689     PythonObject value_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_value));
79690     PythonObject options_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_options));
79716     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_class_name,dict);
79726     PythonObject val_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_value));
79730     PythonObject result = pfunc(val_arg, dict);
79751     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_class_name, dict);
79757     PythonObject debugger_arg(PyRefType::Owned, SBTypeToSWIGWrapper(debugger_sb));
79758     PythonObject result = pfunc(debugger_arg, dict);
79786     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_class_name, dict);
79794     PythonObject tp_arg(PyRefType::Owned, SBTypeToSWIGWrapper(tp_value));
79799     PythonObject result = {};
79809         PythonObject args_arg(PyRefType::Owned, SBTypeToSWIGWrapper(args_value));
79836     PythonObject self(PyRefType::Borrowed, static_cast<PyObject*>(implementor));
79842     PythonObject result;
79846         PythonObject event_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_event));
79886     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_class_name, dict);
79893     PythonObject bkpt_arg(PyRefType::Owned, SBTypeToSWIGWrapper(bkpt_value));
79896     PythonObject args_arg(PyRefType::Owned, SBTypeToSWIGWrapper(args_value));
79898     PythonObject result = pfunc(bkpt_arg, args_arg, dict);
79923     PythonObject self(PyRefType::Borrowed, static_cast<PyObject*>(implementor));
79929     PythonObject result;
79932       PythonObject sym_ctx_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_sym_ctx));
79974     PythonObject self(PyRefType::Borrowed, static_cast<PyObject*>(implementor));
79988     PythonObject result = pfunc();
79999     PythonObject self(PyRefType::Borrowed, implementor);
80011     PythonObject result;
80048     PythonObject self(PyRefType::Borrowed, implementor);
80054     PythonObject result = pfunc(PythonInteger(idx));
80078     PythonObject self(PyRefType::Borrowed, implementor);
80084     PythonObject result = pfunc(PythonString(child_name));
80201     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name, dict);
80213     PythonObject debugger_arg(PyRefType::Owned, SBTypeToSWIGWrapper(debugger_sb));
80214     PythonObject exe_ctx_arg(PyRefType::Owned, SBTypeToSWIGWrapper(exe_ctx_sb));
80215     PythonObject cmd_retobj_arg(PyRefType::Owned, SBTypeToSWIGWrapper(&cmd_retobj_sb));
80241     PythonObject self(PyRefType::Borrowed, implementor);
80249     PythonObject debugger_arg(PyRefType::Owned, SBTypeToSWIGWrapper(debugger_sb));
80250     PythonObject exe_ctx_arg(PyRefType::Owned, SBTypeToSWIGWrapper(exe_ctx_sb));
80251     PythonObject cmd_retobj_arg(PyRefType::Owned, SBTypeToSWIGWrapper(&cmd_retobj_sb));
80272     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_class_name, dict);
80280     PythonObject process_arg(PyRefType::Owned, SBTypeToSWIGWrapper(process_sb));
80284     auto result = pfunc(process_arg);
80305     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_class_name, dict);
80310     auto result = pfunc();
80343     PythonObject py_module(PyRefType::Borrowed, (PyObject *)module);
80350     PythonObject target_arg(PyRefType::Owned, SBTypeToSWIGWrapper(target_sb));
80351     auto result = pfunc(target_arg, PythonString(setting));
80370     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name, dict);
80376     PythonObject process_arg(PyRefType::Owned, SBTypeToSWIGWrapper(process_sb));
80377     auto result = pfunc(process_arg, dict);
80398     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name, dict);
80404     PythonObject thread_arg(PyRefType::Owned, SBTypeToSWIGWrapper(thread_sb));
80405     auto result = pfunc(thread_arg, dict);
80426     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name,dict);
80432     PythonObject target_arg(PyRefType::Owned, SBTypeToSWIGWrapper(target_sb));
80433     auto result = pfunc(target_arg, dict);
80454     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name,dict);
80460     PythonObject frame_arg(PyRefType::Owned, SBTypeToSWIGWrapper(frame_sb));
80461     auto result = pfunc(frame_arg, dict);
80482     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name, dict);
80488     PythonObject value_arg(PyRefType::Owned, SBTypeToSWIGWrapper(value_sb));
80489     auto result = pfunc(value_arg, dict);
80511     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_function_name, dict);
80519     PythonObject debugger_arg(PyRefType::Owned, SBTypeToSWIGWrapper(debugger_sb));

   30   T t;
   39 template <typename T> union SizerImpl<T> { char arr[sizeof(T)]; };
   50       llvm::detail::SizerImpl<T, Ts...>)];

  437   static const bool isRef = std::is_reference<T>::value;
  439   using wrap = std::reference_wrapper<typename std::remove_reference<T>::type>;
  444   using storage_type = typename std::conditional<isRef, wrap, T>::type;
  445   using value_type = T;
  448   using reference = typename std::remove_reference<T>::type &;
  449   using const_reference = const typename std::remove_reference<T>::type &;
  450   using pointer = typename std::remove_reference<T>::type *;
  451   using const_pointer = const typename std::remove_reference<T>::type *;
  474   Expected(OtherT &&Val,
  475            typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
  475            typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
  483     new (getStorage()) storage_type(std::forward<OtherT>(Val));
  492   Expected(Expected<OtherT> &&Other,
  493            typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
  493            typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
  594   template <class OtherT> void moveConstruct(Expected<OtherT> &&Other) {
  607   template <class OtherT> void moveAssign(Expected<OtherT> &&Other) {

   23 template <typename T> ExpectedHolder<T> TakeExpected(Expected<T> &Exp) {
   23 template <typename T> ExpectedHolder<T> TakeExpected(Expected<T> &Exp) {
   27 template <typename T> ExpectedHolder<T> TakeExpected(Expected<T> &&Exp) {
   27 template <typename T> ExpectedHolder<T> TakeExpected(Expected<T> &&Exp) {

   30   ExpectedHolder(ErrorHolder Err, Expected<T> &Exp)
   33   Expected<T> &Exp;
   51 void PrintTo(const ExpectedHolder<T> &Item, std::ostream *Out) {

   39 template <> Expected<bool> python::As<bool>(Expected<PythonObject> &&obj) {
   46 Expected<long long> python::As<long long>(Expected<PythonObject> &&obj) {
   53 Expected<std::string> python::As<std::string>(Expected<PythonObject> &&obj) {
  141 PythonObject
  146   PythonObject result = dict.GetItemForKey(PythonString(piece));
  157 PythonObject PythonObject::ResolveName(llvm::StringRef name) const {
  177   PythonObject parent = ResolveName(name.substr(0, dot_pos));
  192 PythonObject PythonObject::GetAttributeValue(llvm::StringRef attr) const {
  544 PythonObject PythonList::GetItemAtIndex(uint32_t index) const {
  550 void PythonList::SetItemAtIndex(uint32_t index, const PythonObject &object) {
  559 void PythonList::AppendItem(const PythonObject &object) {
  571     PythonObject obj = GetItemAtIndex(i);
  588 PythonTuple::PythonTuple(std::initializer_list<PythonObject> objects) {
  592   for (auto object : objects) {
  604     PythonObject object(PyRefType::Borrowed, py_object);
  623 PythonObject PythonTuple::GetItemAtIndex(uint32_t index) const {
  629 void PythonTuple::SetItemAtIndex(uint32_t index, const PythonObject &object) {
  642     PythonObject obj = GetItemAtIndex(i);
  674 PythonObject PythonDictionary::GetItemForKey(const PythonObject &key) const {
  674 PythonObject PythonDictionary::GetItemForKey(const PythonObject &key) const {
  683 Expected<PythonObject>
  684 PythonDictionary::GetItem(const PythonObject &key) const {
  696   return Retain<PythonObject>(o);
  699 Expected<PythonObject> PythonDictionary::GetItem(const Twine &key) const {
  707   return Retain<PythonObject>(o);
  710 Error PythonDictionary::SetItem(const PythonObject &key,
  711                                 const PythonObject &value) const {
  721                                 const PythonObject &value) const {
  730 void PythonDictionary::SetItemForKey(const PythonObject &key,
  731                                      const PythonObject &value) {
  743     PythonObject key = keys.GetItemAtIndex(i);
  744     PythonObject value = GetItemForKey(key);
  773 Expected<PythonObject> PythonModule::Get(const Twine &name) {
  782   return Retain<PythonObject>(item);
  876     PythonObject im_self = GetAttributeValue("im_self");
  882       PythonObject __call__ = GetAttributeValue("__call__");
  887           PythonObject im_self = __callable__.GetAttributeValue("im_self");
  925 PythonObject PythonCallable::operator()() {
  929 PythonObject PythonCallable::
  936 PythonObject PythonCallable::
  937 operator()(std::initializer_list<PythonObject> args) {
 1080 GetOptionsForPyObject(const PythonObject &obj) {
 1531   Take<PythonObject>(o);
 1540 llvm::Expected<PythonObject>
 1556   auto code_ref = Take<PythonObject>(code);
 1556   auto code_ref = Take<PythonObject>(code);
 1568   return Take<PythonObject>(result);
 1571 llvm::Expected<PythonObject>
 1581   return Take<PythonObject>(result);

  128 template <typename T> T Take(PyObject *obj) {
  131   T thing(PyRefType::Owned, obj);
  146 template <typename T> T Retain(PyObject *obj) {
  149   T thing(PyRefType::Borrowed, obj);
  232   PythonObject(const PythonObject &rhs)
  235   PythonObject(PythonObject &&rhs) {
  265   PythonObject &operator=(PythonObject other) {
  265   PythonObject &operator=(PythonObject other) {
  277   static PythonObject ResolveNameWithDictionary(llvm::StringRef name,
  286   PythonObject ResolveName(llvm::StringRef name) const;
  294   PythonObject GetAttributeValue(llvm::StringRef attribute) const;
  324   llvm::Expected<PythonObject> CallMethod(const char *name,
  332     return python::Take<PythonObject>(obj);
  336   llvm::Expected<PythonObject> Call(const T &... t) const {
  342     return python::Take<PythonObject>(obj);
  345   llvm::Expected<PythonObject> GetAttribute(const llvm::Twine &name) const {
  351     return python::Take<PythonObject>(obj);
  373   llvm::Expected<bool> IsInstance(const PythonObject &cls) {
  388 template <typename T> llvm::Expected<T> As(llvm::Expected<PythonObject> &&obj) {
  397 template <> llvm::Expected<bool> As<bool>(llvm::Expected<PythonObject> &&obj);
  400 llvm::Expected<long long> As<long long>(llvm::Expected<PythonObject> &&obj);
  403 llvm::Expected<std::string> As<std::string>(llvm::Expected<PythonObject> &&obj);
  406 template <class T> class TypedPythonObject : public PythonObject {
  529   PythonObject GetItemAtIndex(uint32_t index) const;
  531   void SetItemAtIndex(uint32_t index, const PythonObject &object);
  533   void AppendItem(const PythonObject &object);
  544   PythonTuple(std::initializer_list<PythonObject> objects);
  551   PythonObject GetItemAtIndex(uint32_t index) const;
  553   void SetItemAtIndex(uint32_t index, const PythonObject &object);
  572   PythonObject GetItemForKey(const PythonObject &key) const; // DEPRECATED
  572   PythonObject GetItemForKey(const PythonObject &key) const; // DEPRECATED
  573   void SetItemForKey(const PythonObject &key,
  574                      const PythonObject &value); // DEPRECATED
  576   llvm::Expected<PythonObject> GetItem(const PythonObject &key) const;
  576   llvm::Expected<PythonObject> GetItem(const PythonObject &key) const;
  577   llvm::Expected<PythonObject> GetItem(const llvm::Twine &key) const;
  578   llvm::Error SetItem(const PythonObject &key, const PythonObject &value) const;
  578   llvm::Error SetItem(const PythonObject &key, const PythonObject &value) const;
  579   llvm::Error SetItem(const llvm::Twine &key, const PythonObject &value) const;
  609   llvm::Expected<PythonObject> Get(const llvm::Twine &name);
  648   PythonObject operator()();
  650   PythonObject operator()(std::initializer_list<PyObject *> args);
  652   PythonObject operator()(std::initializer_list<PythonObject> args);
  652   PythonObject operator()(std::initializer_list<PythonObject> args);
  655   PythonObject operator()(const Arg &arg, Args... args) {
  655   PythonObject operator()(const Arg &arg, Args... args) {
  655   PythonObject operator()(const Arg &arg, Args... args) {
  734 llvm::Expected<PythonObject> runStringOneLine(const llvm::Twine &string,
  738 llvm::Expected<PythonObject> runStringMultiLine(const llvm::Twine &string,
  769   llvm::Expected<PythonObject> operator()(Args &&... args) {

  645                                                PythonObject &save_file,
  763   PythonObject &main_module = GetMainModule();
  800      = PythonObject::ResolveNameWithDictionary<PythonCallable>(callable_name, 
  831   PythonObject module(PyRefType::Borrowed,
  966             PythonObject pargs(
  970               PythonObject return_value(
 1083   Expected<PythonObject> maybe_py_return =
 1102   PythonObject py_return = std::move(maybe_py_return.get());
 1195   Expected<PythonObject> return_value =
 1533   PythonObject implementor(PyRefType::Borrowed,
 1539   PythonObject py_return(PyRefType::Owned,
 1598   PythonObject implementor(PyRefType::Borrowed,
 1604   PythonObject pmeth(PyRefType::Owned,
 1624   PythonObject py_return(
 1653   PythonObject implementor(PyRefType::Borrowed,
 1659   PythonObject pmeth(PyRefType::Owned,
 1679   PythonObject py_return(
 1740   PythonObject implementor(PyRefType::Borrowed,
 1746   PythonObject pmeth(PyRefType::Owned,
 1765   PythonObject py_return(
 1799   PythonObject implementor(PyRefType::Borrowed,
 1805   PythonObject pmeth(PyRefType::Owned,
 1824   PythonObject py_return(PyRefType::Owned,
 2055       unwrapIgnoringErrors(As<PythonDictionary>(Take<PythonObject>(setting)));
 2506   PythonObject implementor(PyRefType::Borrowed,
 2511   PythonObject pmeth(PyRefType::Owned,
 2530   PythonObject py_return(
 3014   PythonObject implementor(PyRefType::Borrowed,
 3020   PythonObject pmeth(PyRefType::Owned,
 3039   PythonObject py_return(
 3069   PythonObject implementor(PyRefType::Borrowed,
 3075   PythonObject pmeth(PyRefType::Owned,
 3094   PythonObject py_return(
 3124   PythonObject implementor(PyRefType::Borrowed,
 3130   PythonObject pmeth(PyRefType::Owned,
 3150   PythonObject py_return(

  389                     python::PythonObject &save_file, const char *mode);
  391   python::PythonObject m_saved_stdin;
  392   python::PythonObject m_saved_stdout;
  393   python::PythonObject m_saved_stderr;
  397   python::PythonObject m_run_one_line_function;
  398   python::PythonObject m_run_one_line_str_global;

   58   PythonObject owned_long(PyRefType::Owned, obj);
   62   PythonObject strong_ref(owned_long);
   93   PythonObject sys_module = m_main_module.ResolveName("sys");
  100   PythonObject sys_path = m_sys_module.ResolveName("path");
  101   PythonObject sys_version_info = m_sys_module.ResolveName("version_info");
  109   PythonObject sys_version_info = m_sys_module.ResolveName("version_info");
  111   PythonObject version_info_type(PyRefType::Owned,
  114   PythonObject major_version_field = version_info_type.ResolveName("major");
  119   PythonObject sys_version_info = m_sys_module.ResolveName("version_info");
  120   PythonObject major_version_field = sys_version_info.ResolveName("major");
  121   PythonObject minor_version_field = sys_version_info.ResolveName("minor");
  136   PythonObject sys_path = m_main_module.ResolveName("sys.path");
  159       PythonObject::ResolveNameWithDictionary("sys.version_info.major", dict)
  162       PythonObject::ResolveNameWithDictionary("sys.version_info.minor", dict)
  323   PythonObject list_items[list_size];
  334   PythonObject chk_value1 = list.GetItemAtIndex(0);
  335   PythonObject chk_value2 = list.GetItemAtIndex(1);
  362   PythonObject chk_value1 = list.GetItemAtIndex(0);
  363   PythonObject chk_value2 = list.GetItemAtIndex(1);
  408   PythonObject none_value(PyRefType::Borrowed, Py_None);
  422   PythonObject none_value(PyRefType::Borrowed, Py_None);
  434   PythonObject none_value(PyRefType::Borrowed, Py_None);
  467   PythonObject py_keys[dict_entries];
  468   PythonObject py_values[dict_entries];
  485   PythonObject chk_value1 = dict.GetItemForKey(py_keys[0]);
  486   PythonObject chk_value2 = dict.GetItemForKey(py_keys[1]);
  508   PythonObject values[dict_entries];
  522   PythonObject chk_value1 = dict.GetItemForKey(keys[0]);
  523   PythonObject chk_value2 = dict.GetItemForKey(keys[1]);
  559   PythonObject sys_exc_info = m_sys_module.ResolveName("exc_info");
  560   PythonObject none(PyRefType::Borrowed, Py_None);
  573   PythonObject result = list({tuple_to_convert});
  720     Take<PythonObject>(o);
  842   Expected<PythonObject> r = runStringOneLine("n = 42", globals, globals);

   72     constexpr _Tp&&
   73     forward(typename std::remove_reference<_Tp>::type& __t) noexcept
   83     constexpr _Tp&&
   84     forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
   98     move(_Tp&& __t) noexcept

   50       typedef _E 		value_type;
   51       typedef const _E& 	reference;
   52       typedef const _E& 	const_reference;
   54       typedef const _E* 	iterator;
   55       typedef const _E* 	const_iterator;

  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  762     typename add_rvalue_reference<_Tp>::type declval() noexcept;
 1526 	static void __test_aux(_To1);
 1538       typedef decltype(__test<_From, _To>(0)) type;
 1538       typedef decltype(__test<_From, _To>(0)) type;
 1545     : public __is_convertible_helper<_From, _To>::type
 1545     : public __is_convertible_helper<_From, _To>::type
 1554     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1629     { typedef _Tp   type; };
 1633     { typedef _Tp   type; };
 1659     { typedef _Tp&&   type; };
 1664     : public __add_rvalue_reference_helper<_Tp>
 2171     { typedef _Iffalse type; };

  140   static void PrintValue(const T& value, ::std::ostream* os) {
  205     ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
  206   TypeWithoutFormatter<T,
  207       (internal::IsAProtocolMessage<T>::value ? kProtobuf :
  208        internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
  223 void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
  366 void UniversalPrint(const T& value, ::std::ostream* os);
  373                     const C& container, ::std::ostream* os) {
  439                     const T& value, ::std::ostream* os) {
  455 void PrintTo(const T& value, ::std::ostream* os) {
  478   DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
  699   static void Print(const T& value, ::std::ostream* os) {
  784   static void Print(const T& value, ::std::ostream* os) {
  856   typedef T T1;
  981 ::std::string PrintToString(const T& value) {
  983   internal::UniversalTersePrinter<T>::Print(value, &ss);

   29   static const T& printable(const T& V) { return V; }
   29   static const T& printable(const T& V) { return V; }
   35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
   35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
   37   return StreamSwitch<T>::printable(V);