- inline iterator begin() { return MethodList.begin(); }
- inline const_iterator begin() const { return MethodList.begin(); }
- inline iterator end () { return MethodList.end(); }
- inline const_iterator end () const { return MethodList.end(); }
-
- inline reverse_iterator rbegin() { return MethodList.rbegin(); }
- inline const_reverse_iterator rbegin() const { return MethodList.rbegin(); }
- inline reverse_iterator rend () { return MethodList.rend(); }
- inline const_reverse_iterator rend () const { return MethodList.rend(); }
-
- inline unsigned size() const { return MethodList.size(); }
- inline bool empty() const { return MethodList.empty(); }
- inline const Method *front() const { return MethodList.front(); }
- inline Method *front() { return MethodList.front(); }
- inline const Method *back() const { return MethodList.back(); }
- inline Method *back() { return MethodList.back(); }
-
-
- // dropAllReferences() - This function causes all the subinstructions to "let
- // go" of all references that they are maintaining. This allows one to
- // 'delete' a whole class at a time, even though there may be circular
- // references... first all references are dropped, and all use counts go to
- // zero. Then everything is delete'd for real. Note that no operations are
- // valid on an object that has "dropped all references", except operator
- // delete.
- //
+ inline giterator gbegin() { return GlobalList.begin(); }
+ inline const_giterator gbegin() const { return GlobalList.begin(); }
+ inline giterator gend () { return GlobalList.end(); }
+ inline const_giterator gend () const { return GlobalList.end(); }
+
+ inline reverse_giterator grbegin() { return GlobalList.rbegin(); }
+ inline const_reverse_giterator grbegin() const { return GlobalList.rbegin(); }
+ inline reverse_giterator grend () { return GlobalList.rend(); }
+ inline const_reverse_giterator grend () const { return GlobalList.rend(); }
+
+ inline unsigned gsize() const { return GlobalList.size(); }
+ inline bool gempty() const { return GlobalList.empty(); }
+ inline const GlobalVariable &gfront() const { return GlobalList.front(); }
+ inline GlobalVariable &gfront() { return GlobalList.front(); }
+ inline const GlobalVariable &gback() const { return GlobalList.back(); }
+ inline GlobalVariable &gback() { return GlobalList.back(); }
+
+
+
+ inline iterator begin() { return FunctionList.begin(); }
+ inline const_iterator begin() const { return FunctionList.begin(); }
+ inline iterator end () { return FunctionList.end(); }
+ inline const_iterator end () const { return FunctionList.end(); }
+
+ inline reverse_iterator rbegin() { return FunctionList.rbegin(); }
+ inline const_reverse_iterator rbegin() const { return FunctionList.rbegin(); }
+ inline reverse_iterator rend () { return FunctionList.rend(); }
+ inline const_reverse_iterator rend () const { return FunctionList.rend(); }
+
+ inline unsigned size() const { return FunctionList.size(); }
+ inline bool empty() const { return FunctionList.empty(); }
+ inline const Function &front() const { return FunctionList.front(); }
+ inline Function &front() { return FunctionList.front(); }
+ inline const Function &back() const { return FunctionList.back(); }
+ inline Function &back() { return FunctionList.back(); }
+
+ void print(std::ostream &OS) const;
+ void dump() const;
+
+ /// dropAllReferences() - This function causes all the subinstructions to "let
+ /// go" of all references that they are maintaining. This allows one to
+ /// 'delete' a whole class at a time, even though there may be circular
+ /// references... first all references are dropped, and all use counts go to
+ /// zero. Then everything is delete'd for real. Note that no operations are
+ /// valid on an object that has "dropped all references", except operator
+ /// delete.
+ ///