Tue Aug 13 01:31:08 PDT 2013

1 files changed, 325 insertions, 0 deletions

diff --git a/community/google-gadgets/gcc47.patch b/community/google-gadgets/gcc47.patch
new file mode 100644
index 000000000..2e77e10fd
--- /dev/null
+++ b/community/google-gadgets/gcc47.patch
@@ -0,0 +1,325 @@
+Author: Pino Toscano <pino@debian.org>
+Description: Fix building with GCC 4.7
+ This patch fixes the two kinds of issues that arise with GCC 4.7:
+ - include <unistd.h> for functions like access(), fork(), readlink(), etc
+ - fix argument-dependent lookup issues by qualifying the lookup of functions
+Forwarded: no
+Last-Update: 2012-04-04
+
+--- a/ggadget/scriptable_enumerator.h
++++ b/ggadget/scriptable_enumerator.h
+@@ -68,22 +68,22 @@
+ 
+  protected:
+   virtual void DoClassRegister() {
+-    RegisterMethod("atEnd",
++    this->RegisterMethod("atEnd",
+                    NewSlot(&E::AtEnd,
+                            &ScriptableEnumerator<E, Wrapper, Param, ClassId>
+                                ::enumerator_));
+-    RegisterMethod("moveFirst",
++    this->RegisterMethod("moveFirst",
+                    NewSlot(&E::MoveFirst,
+                            &ScriptableEnumerator<E, Wrapper, Param, ClassId>
+                                ::enumerator_));
+-    RegisterMethod("moveNext",
++    this->RegisterMethod("moveNext",
+                    NewSlot(&E::MoveNext,
+                            &ScriptableEnumerator<E, Wrapper, Param, ClassId>
+                                ::enumerator_));
+-    RegisterMethod("item",
++    this->RegisterMethod("item",
+                    NewSlot(&ScriptableEnumerator<E, Wrapper, Param, ClassId>
+                                ::GetItem));
+-    RegisterProperty("count",
++    this->RegisterProperty("count",
+                      NewSlot(&E::GetCount,
+                              &ScriptableEnumerator<E, Wrapper, Param, ClassId>
+                                  ::enumerator_),
+--- a/ggadget/uuid.cc
++++ b/ggadget/uuid.cc
+@@ -24,6 +24,7 @@
+ #include <cstdlib>
+ #include <cstring>
+ #include <ctime>
++#include <unistd.h>
+ 
+ #include "string_utils.h"
+ 
+--- a/ggadget/xml_dom.cc
++++ b/ggadget/xml_dom.cc
+@@ -1327,15 +1327,15 @@
+ 
+   virtual void DoClassRegister() {
+     Super::DoClassRegister();
+-    RegisterProperty("data", NewSlot(&DOMCharacterData::GetData),
++    this->RegisterProperty("data", NewSlot(&DOMCharacterData::GetData),
+                      NewSlot(&DOMCharacterData::SetData));
+-    RegisterProperty("length", NewSlot(&DOMCharacterData::GetLength), NULL);
+-    RegisterMethod("substringData",
++    this->RegisterProperty("length", NewSlot(&DOMCharacterData::GetLength), NULL);
++    this->RegisterMethod("substringData",
+                    NewSlot(&DOMCharacterData::ScriptSubstringData));
+-    RegisterMethod("appendData", NewSlot(&DOMCharacterData::AppendData));
+-    RegisterMethod("insertData", NewSlot(&DOMCharacterData::ScriptInsertData));
+-    RegisterMethod("deleteData", NewSlot(&DOMCharacterData::ScriptDeleteData));
+-    RegisterMethod("replaceData",
++    this->RegisterMethod("appendData", NewSlot(&DOMCharacterData::AppendData));
++    this->RegisterMethod("insertData", NewSlot(&DOMCharacterData::ScriptInsertData));
++    this->RegisterMethod("deleteData", NewSlot(&DOMCharacterData::ScriptDeleteData));
++    this->RegisterMethod("replaceData",
+                    NewSlot(&DOMCharacterData::ScriptReplaceData));
+   }
+ 
+@@ -1377,20 +1377,20 @@
+  private:
+   UTF16String ScriptSubstringData(size_t offset, size_t count) {
+     UTF16String result;
+-    CheckException(SubstringData(offset, count, &result));
++    this->CheckException(SubstringData(offset, count, &result));
+     return result;
+   }
+ 
+   void ScriptInsertData(size_t offset, const UTF16String &arg) {
+-    CheckException(InsertData(offset, arg));
++    this->CheckException(InsertData(offset, arg));
+   }
+ 
+   void ScriptDeleteData(size_t offset, size_t count) {
+-    CheckException(DeleteData(offset, count));
++    this->CheckException(DeleteData(offset, count));
+   }
+ 
+   void ScriptReplaceData(size_t offset, size_t count, const UTF16String &arg) {
+-    CheckException(ReplaceData(offset, count, arg));
++    this->CheckException(ReplaceData(offset, count, arg));
+   }
+ 
+   DOMCharacterDataImpl impl_;
+@@ -1417,10 +1417,10 @@
+ 
+   virtual void DoClassRegister() {
+     Super::DoClassRegister();
+-    RegisterProperty("name", NewSlot(&DOMAttr::GetName), NULL);
++    this->RegisterProperty("name", NewSlot(&DOMAttr::GetName), NULL);
+     // Our DOMAttrs are always specified, because we don't support DTD for now.
+-    RegisterConstant("specified", true);
+-    RegisterProperty("value", NewSlot(&DOMAttr::GetValue),
++    this->RegisterConstant("specified", true);
++    this->RegisterProperty("value", NewSlot(&DOMAttr::GetValue),
+                      NewSlot(&DOMAttr::SetValue));
+     // ownerElement is a DOM2 property, so not registered for now.
+   }
+@@ -1516,19 +1516,19 @@
+ 
+   virtual void DoClassRegister() {
+     Super::DoClassRegister();
+-    RegisterProperty("tagName", NewSlot(&DOMElement::GetTagName), NULL);
+-    RegisterMethod("getAttribute", NewSlot(&DOMElement::GetAttribute));
+-    RegisterMethod("setAttribute",
++    this->RegisterProperty("tagName", NewSlot(&DOMElement::GetTagName), NULL);
++    this->RegisterMethod("getAttribute", NewSlot(&DOMElement::GetAttribute));
++    this->RegisterMethod("setAttribute",
+                    NewSlot(&DOMElement::ScriptSetAttribute));
+-    RegisterMethod("removeAttribute",
++    this->RegisterMethod("removeAttribute",
+                    NewSlot(&DOMElement::RemoveAttribute));
+-    RegisterMethod("getAttributeNode",
++    this->RegisterMethod("getAttributeNode",
+                    NewSlot(&DOMElement::GetAttributeNodeNotConst));
+-    RegisterMethod("setAttributeNode",
++    this->RegisterMethod("setAttributeNode",
+                    NewSlot(&DOMElement::ScriptSetAttributeNode));
+-    RegisterMethod("removeAttributeNode",
++    this->RegisterMethod("removeAttributeNode",
+                    NewSlot(&DOMElement::ScriptRemoveAttributeNode));
+-    RegisterMethod("getElementsByTagName",
++    this->RegisterMethod("getElementsByTagName",
+                    NewSlot(&Super::GetElementsByTagNameNotConst));
+   }
+ 
+@@ -1696,16 +1696,16 @@
+     }
+ 
+     virtual void DoClassRegister() {
+-      RegisterProperty("length", NewSlot(&AttrsNamedMap::GetLength), NULL);
+-      RegisterMethod("getNamedItem",
++      this->RegisterProperty("length", NewSlot(&AttrsNamedMap::GetLength), NULL);
++      this->RegisterMethod("getNamedItem",
+                      NewSlot(&AttrsNamedMap::GetNamedItemNotConst));
+-      RegisterMethod("setNamedItem",
++      this->RegisterMethod("setNamedItem",
+                      NewSlot(&AttrsNamedMap::ScriptSetNamedItem));
+-      RegisterMethod("removeNamedItem",
++      this->RegisterMethod("removeNamedItem",
+                      NewSlot(&AttrsNamedMap::ScriptRemoveNamedItem));
+-      RegisterMethod("item", NewSlot(&AttrsNamedMap::GetItemNotConst));
++      this->RegisterMethod("item", NewSlot(&AttrsNamedMap::GetItemNotConst));
+       // Microsoft compatibility.
+-      RegisterMethod("", NewSlot(&AttrsNamedMap::GetItemNotConst));
++      this->RegisterMethod("", NewSlot(&AttrsNamedMap::GetItemNotConst));
+     }
+ 
+     virtual DOMNodeInterface *GetNamedItem(const std::string &name) {
+@@ -1875,7 +1875,7 @@
+ 
+   virtual void DoClassRegister() {
+     Super::DoClassRegister();
+-    RegisterMethod("splitText", NewSlot(&DOMText::ScriptSplitText));
++    this->RegisterMethod("splitText", NewSlot(&DOMText::ScriptSplitText));
+   }
+ 
+   virtual NodeType GetNodeType() const { return TEXT_NODE; }
+@@ -2060,9 +2060,9 @@
+ 
+   virtual void DoClassRegister() {
+     Super::DoClassRegister();
+-    RegisterProperty("target",
++    this->RegisterProperty("target",
+                      NewSlot(&DOMProcessingInstruction::GetTarget), NULL);
+-    RegisterProperty("data", NewSlot(&DOMProcessingInstruction::GetData),
++    this->RegisterProperty("data", NewSlot(&DOMProcessingInstruction::GetData),
+                      NewSlot(&DOMProcessingInstruction::SetData));
+   }
+ 
+@@ -2109,7 +2109,7 @@
+   DEFINE_CLASS_ID(0xd23149a89cf24e12, DOMImplementationInterface);
+ 
+   virtual void DoClassRegister() {
+-    RegisterMethod("hasFeature", NewSlot(&DOMImplementation::HasFeature));
++    this->RegisterMethod("hasFeature", NewSlot(&DOMImplementation::HasFeature));
+   }
+ 
+   virtual bool HasFeature(const char *feature, const char *version) const {
+@@ -2129,13 +2129,13 @@
+   void SetCode(int code) { code_ = code; }
+ 
+   virtual void DoClassRegister() {
+-    RegisterProperty("errorCode", NewSlot(&ParseError::GetCode), NULL);
+-    RegisterConstant("filepos", 0);
+-    RegisterConstant("line", 0);
+-    RegisterConstant("linepos", 0);
+-    RegisterConstant("reason", "");
+-    RegisterConstant("srcText", "");
+-    RegisterConstant("url", "");
++    this->RegisterProperty("errorCode", NewSlot(&ParseError::GetCode), NULL);
++    this->RegisterConstant("filepos", 0);
++    this->RegisterConstant("line", 0);
++    this->RegisterConstant("linepos", 0);
++    this->RegisterConstant("reason", "");
++    this->RegisterConstant("srcText", "");
++    this->RegisterConstant("url", "");
+   }
+ 
+  private:
+@@ -2180,45 +2180,45 @@
+ 
+   virtual void DoClassRegister() {
+     Super::DoClassRegister();
+-    RegisterConstant("doctype", static_cast<ScriptableInterface *>(NULL));
+-    RegisterConstant("implementation", &dom_implementation_);
+-    RegisterProperty("documentElement",
++    this->RegisterConstant("doctype", static_cast<ScriptableInterface *>(NULL));
++    this->RegisterConstant("implementation", &dom_implementation_);
++    this->RegisterProperty("documentElement",
+                      NewSlot(&DOMDocument::GetDocumentElementNotConst), NULL);
+-    RegisterMethod("loadXML", NewSlot(&DOMDocument::LoadXML));
+-    RegisterMethod("createElement",
++    this->RegisterMethod("loadXML", NewSlot(&DOMDocument::LoadXML));
++    this->RegisterMethod("createElement",
+                    NewSlot(&DOMDocument::ScriptCreateElement));
+-    RegisterMethod("createDocumentFragment",
++    this->RegisterMethod("createDocumentFragment",
+                    NewSlot(&DOMDocument::CreateDocumentFragment));
+-    RegisterMethod("createTextNode",
++    this->RegisterMethod("createTextNode",
+                    NewSlot(&DOMDocument::CreateTextNode));
+-    RegisterMethod("createComment", NewSlot(&DOMDocument::CreateComment));
+-    RegisterMethod("createCDATASection",
++    this->RegisterMethod("createComment", NewSlot(&DOMDocument::CreateComment));
++    this->RegisterMethod("createCDATASection",
+                    NewSlot(&DOMDocument::CreateCDATASection));
+-    RegisterMethod("createProcessingInstruction",
++    this->RegisterMethod("createProcessingInstruction",
+                    NewSlot(&DOMDocument::ScriptCreateProcessingInstruction));
+-    RegisterMethod("createAttribute",
++    this->RegisterMethod("createAttribute",
+                    NewSlot(&DOMDocument::ScriptCreateAttribute));
+-    RegisterMethod("createEntityReference",
++    this->RegisterMethod("createEntityReference",
+                    NewSlot(&DOMDocument::ScriptCreateEntityReference));
+-    RegisterMethod("getElementsByTagName",
++    this->RegisterMethod("getElementsByTagName",
+                    NewSlot(&Super::GetElementsByTagNameNotConst));
+-    RegisterMethod("importNode", NewSlot(&DOMDocument::ScriptImportNode));
++    this->RegisterMethod("importNode", NewSlot(&DOMDocument::ScriptImportNode));
+     // Compatibility with Microsoft DOM.
+-    RegisterProperty("parsed", NewFixedGetterSlot(true), NULL);
+-    RegisterProperty("parseError", NewSlot(&DOMDocument::GetParseError), NULL);
+-    RegisterProperty("resolveExternals", NULL, NewSlot(&DummySetter));
+-    RegisterProperty("validateOnParse", NULL, NewSlot(&DummySetter));
+-    RegisterProperty("preserveWhiteSpace",
++    this->RegisterProperty("parsed", NewFixedGetterSlot(true), NULL);
++    this->RegisterProperty("parseError", NewSlot(&DOMDocument::GetParseError), NULL);
++    this->RegisterProperty("resolveExternals", NULL, NewSlot(&DummySetter));
++    this->RegisterProperty("validateOnParse", NULL, NewSlot(&DummySetter));
++    this->RegisterProperty("preserveWhiteSpace",
+                      NewSlot(&DOMDocument::PreservesWhiteSpace),
+                      NewSlot(&DOMDocument::SetPreserveWhiteSpace));
+-    RegisterMethod("getProperty", NewSlot(DummyGetProperty));
+-    RegisterMethod("setProperty", NewSlot(DummySetProperty));
++    this->RegisterMethod("getProperty", NewSlot(DummyGetProperty));
++    this->RegisterMethod("setProperty", NewSlot(DummySetProperty));
+     // Compatibility with Microsoft DOM: XMLHttpRequest functions.
+-    RegisterProperty("async", NewSlot(&DOMDocument::IsAsync),
++    this->RegisterProperty("async", NewSlot(&DOMDocument::IsAsync),
+                      NewSlot(&DOMDocument::SetAsync));
+-    RegisterProperty("readyState", NewSlot(&DOMDocument::GetReadyState), NULL);
+-    RegisterMethod("load", NewSlot(&DOMDocument::Load));
+-    RegisterClassSignal("onreadystatechange",
++    this->RegisterProperty("readyState", NewSlot(&DOMDocument::GetReadyState), NULL);
++    this->RegisterMethod("load", NewSlot(&DOMDocument::Load));
++    this->RegisterClassSignal("onreadystatechange",
+                         &DOMDocument::onreadystatechange_signal_);
+   }
+ 
+--- a/ggadget/xdg/icon_theme.cc
++++ b/ggadget/xdg/icon_theme.cc
+@@ -16,6 +16,7 @@
+ #include <sys/time.h>
+ #include <time.h>
+ #include <cstdlib>
++#include <unistd.h>
+ 
+ #include <map>
+ #include <vector>
+--- a/extensions/qt_system_framework/qt_system_framework.cc
++++ b/extensions/qt_system_framework/qt_system_framework.cc
+@@ -32,6 +32,7 @@
+ #include <ggadget/xdg/desktop_entry.h>
+ #include <ggadget/xdg/icon_theme.h>
+ #include <ggadget/xdg/utilities.h>
++#include <unistd.h>
+ 
+ #define Initialize qt_system_framework_LTX_Initialize
+ #define Finalize qt_system_framework_LTX_Finalize
+--- a/extensions/linux_system_framework/process.cc
++++ b/extensions/linux_system_framework/process.cc
+@@ -17,6 +17,7 @@
+ #include <sys/types.h>
+ #include <dirent.h>
+ #include <cstdlib>
++#include <unistd.h>
+ 
+ #ifdef HAVE_X11
+ #include <X11/Xlib.h>
+--- a/gadgets/designer/designer_script_utils.cc
++++ b/gadgets/designer/designer_script_utils.cc
+@@ -39,6 +39,7 @@
+ #include <ggadget/system_utils.h>
+ #include <ggadget/uuid.h>
+ #include <ggadget/view_interface.h>
++#include <unistd.h>
+ 
+ namespace ggadget {
+ namespace designer {