Attachment 19799 Details for Bug 42949 – Preprocessed C++ source.

Preprocessed C++ source.

ice.ii (text/plain), 6.20 KB, created by Ryan Mansfield on 2010-02-03 20:47:27 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Ryan Mansfield

Created: 2010-02-03 20:47:27 UTC

Size: 6.20 KB

patch

obsolete

>extern void foobar();
>namespace std {
>      template<class _Elem>  struct char_traits  { };
>      template<class _Ty>  class allocator    {
>      public:           typedef unsigned size_type;
>      template<class _Other>   struct rebind   {
>     	 typedef allocator<_Other> other;
>    	 };
>	};
>
> template<class _Elem,  class _Traits = char_traits<_Elem>,  class _Ax = allocator<_Elem> >  class basic_string;
> template<class _Ty,  class _Alloc>  class _String_val {
>           protected: typedef typename _Alloc::template   rebind<_Ty>::other _Alty;
>             _Alty _Alval;
>            };
>                  template<class _Elem,  class _Traits,  class _Ax>  class basic_string   : public _String_val<_Elem, _Ax>  {
>           public:  typedef basic_string<_Elem, _Traits, _Ax> _Myt;
>            typedef _String_val<_Elem, _Ax> _Mybase;
>            typedef typename _Mybase::_Alty _Alloc;
>            typedef typename _Alloc::size_type size_type;
>             ~basic_string()   {
>   	 foobar();
>            }
>             const _Elem *c_str() const   {
>   return (_Myptr());
>   }
>              union _Bxty   { _Elem _Buf[19]; } _Bx;
>             const _Elem *_Myptr() const   {
>            return (_Bx._Buf);
>            }
>            size_type _Myres;
>   };
>                      }
>                     template<class T> class pool_allocator {
>                  };
>                     typedef pool_allocator<char> TStringAllocator;
>                     typedef std::basic_string <char, std::char_traits<char>, TStringAllocator > TString;
>                          template <class T> class TVector  {
>     };
>                       inline std::basic_string<char> FormatSourceLoc(const int loc) {
>                }
>                     enum TBasicType {
>                       EBtype, EBfoo, EbInt, foo1, bar5 };
>                       enum foo {
>      };
>                      struct TTLine {
>                };
>         typedef TVector<TTLine> TTList;
>         class TT {
>                public:          virtual TBasicType gbt() const {
>   }
>             int gOS() const     {
>   }
>     	TBasicType type : 6;
>             int arraySize;
>             TTList* structure;
>             mutable int structureSize;
>             int maxArraySize;
>             TT* ait;
>             TString *fieldName;
>             TString *mangled;
>             TString *tN;
>             bool flat;
>             foo precision;
>            };
>         	 class cu {
>     	public:   	void setFConst(float f) {
>   fConst = f;
>   }
>                    bool operator==(const int i) const     {
>   }
>                    cu operator+(const cu& constant) const     {
>                  cu returnValue;
>                  switch (type) {
>                  case EBfoo: returnValue.setFConst(fConst + constant.fConst);
>        foobar();
>                  }
>                    return returnValue;
>               }
>                private:      union {
>                   float fConst;
>               }
>                ;
>                     TBasicType type;
>                };
>                          enum TOperator {
>     fooOP1, fooOP2, fooOP3, fooOP4, fooOP5 };
>                      class TInfoSink;
>                  class TTT {
>                public:     TTT(const TT& t) {
>   }
>                 virtual TT gt() const {
>   }
>                };
>          class ticu : public TTT {
>           public:     ticu(cu *up, const TT& t) :         TTT(t),         uap(up) {
>         }
>           cu* gup() const {
>   }
>           virtual TTT* fold(TOperator, TTT*, TInfoSink&);
>           protected:  	    cu *uap;
>           };
>                enum TPT {
>     gg, pwarn  };
>                class TISB {
>                public:                   void location(int loc) {
>   		append(FormatSourceLoc(loc).c_str());
>           }
>                    void message(TPT message, const char* s, int loc) {
>                   location(loc);
>               }
>                 protected:      void append(const char *s);
>                };
>                       class TInfoSink {
>                public:     TISB info;
>                };
>          bool cmp(const TT& leftNodeType, cu* rua, cu* lua);
>         TTT* ticu::fold(TOperator op, TTT* cn, TInfoSink& blah) {
>                     cu *uA;
>                     int objectSize = gt().gOS();
>                     if (1) {
>                   ticu *node;
>                   cu *rua;
>                    TT returnType = gt();
>                     if (cn->gt().gOS() == 1 && objectSize > 1) {
>                      returnType =gt();
>                  }
>           else if (cn->gt().gOS() > 1 && objectSize == 1) {
>                      cn->gt().gOS();
>                      for (int i = 0;
>   i < cn->gt().gOS();
>   ++i)  {
>  }
>                       node->gt();
>                      objectSize = cn->gt().gOS();
>                  }
>                    cu* tCA = 0;
>   		void *tmp;
>   		int t;
>                   switch(t) {
>                  case 0:                       {
>                        for (int i = 0;
>   i < objectSize;
>   i++)                     tCA[i] = uA[i] + rua[i];
>                    }
>                   case 1:             if ( gt().gbt() != 0 ) {
>                        blah.info.message(gg, "", 0);
>                    }
>                      {
>                        for (int i = 0;
>   i < objectSize;
>   i++) {
>                          switch (gt().gbt()) {
>                        case 5:                         if (rua[i] == 0.0f) {
>                                blah.info.message(pwarn, "", 0);
>                                blah.info.message(pwarn, "", 0);
>                            }
>                        default:                         blah.info.message(gg, "", 0);
>                        }
>                      }
>                        blah.info.message(gg, "", 0);
>                    }
>                    tmp =  new ticu(tCA, node->gt());
>                   case 2:             if (gt().gbt() == EBtype) {
>                        if (!cmp(node->gt(), node->gup(), uA))            {
>  }
>                     }
>                   case 3:             if (gt().gbt() == EBtype) {
>                         if (cmp(node->gt(), node->gup(), uA))  {
>  }
>                    }
>                   default:             blah.info.message(gg, "", 10);
>                  }
>               }
>     }

Actions: View

Attachments on bug 42949: 19799