Bug 906852 - Make layout/style/nsFontFaceLoader.* pointer notation follow layout code style. r=mats
authorBirunthan Mohanathas <birunthan@mohanathas.com>
Wed, 25 Sep 2013 09:48:20 -0400
changeset 148667 eb18a564629a5060160345f2b7bbe583fd083ac7
parent 148666 0d924e17bba428895d796075c2689048be0ea3cf
child 148668 ab3635da717ea961c688cb69d69b595a03462f9a
push id25352
push userkwierso@gmail.com
push dateThu, 26 Sep 2013 03:27:24 +0000
treeherdermozilla-central@94548c13fd47 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmats
bugs906852
milestone27.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 906852 - Make layout/style/nsFontFaceLoader.* pointer notation follow layout code style. r=mats
layout/style/nsFontFaceLoader.cpp
layout/style/nsFontFaceLoader.h
--- a/layout/style/nsFontFaceLoader.cpp
+++ b/layout/style/nsFontFaceLoader.cpp
@@ -33,35 +33,35 @@
 #include "nsIConsoleService.h"
 
 #include "nsStyleSet.h"
 #include "nsPrintfCString.h"
 
 using namespace mozilla;
 
 #ifdef PR_LOGGING
-static PRLogModuleInfo *
+static PRLogModuleInfo* 
 GetFontDownloaderLog()
 {
-  static PRLogModuleInfo *sLog;
+  static PRLogModuleInfo* sLog;
   if (!sLog)
     sLog = PR_NewLogModule("fontdownloader");
   return sLog;
 }
 #endif /* PR_LOGGING */
 
 #define LOG(args) PR_LOG(GetFontDownloaderLog(), PR_LOG_DEBUG, args)
 #define LOG_ENABLED() PR_LOG_TEST(GetFontDownloaderLog(), PR_LOG_DEBUG)
 
 
-nsFontFaceLoader::nsFontFaceLoader(gfxMixedFontFamily *aFontFamily,
-                                   gfxProxyFontEntry *aProxy,
-                                   nsIURI *aFontURI,
-                                   nsUserFontSet *aFontSet,
-                                   nsIChannel *aChannel)
+nsFontFaceLoader::nsFontFaceLoader(gfxMixedFontFamily* aFontFamily,
+                                   gfxProxyFontEntry* aProxy,
+                                   nsIURI* aFontURI,
+                                   nsUserFontSet* aFontSet,
+                                   nsIChannel* aChannel)
   : mFontFamily(aFontFamily),
     mFontEntry(aProxy),
     mFontURI(aFontURI),
     mFontSet(aFontSet),
     mChannel(aChannel)
 {
 }
 
@@ -75,17 +75,17 @@ nsFontFaceLoader::~nsFontFaceLoader()
     mLoadTimer = nullptr;
   }
   if (mFontSet) {
     mFontSet->RemoveLoader(this);
   }
 }
 
 void
-nsFontFaceLoader::StartedLoading(nsIStreamLoader *aStreamLoader)
+nsFontFaceLoader::StartedLoading(nsIStreamLoader* aStreamLoader)
 {
   int32_t loadTimeout =
     Preferences::GetInt("gfx.downloadable_fonts.fallback_delay", 3000);
   if (loadTimeout > 0) {
     mLoadTimer = do_CreateInstance("@mozilla.org/timer;1");
     if (mLoadTimer) {
       mLoadTimer->InitWithFuncCallback(LoadTimerCallback,
                                        static_cast<void*>(this),
@@ -94,26 +94,26 @@ nsFontFaceLoader::StartedLoading(nsIStre
     }
   } else {
     mFontEntry->mLoadingState = gfxProxyFontEntry::LOADING_SLOWLY;
   }
   mStreamLoader = aStreamLoader;
 }
 
 void
-nsFontFaceLoader::LoadTimerCallback(nsITimer *aTimer, void *aClosure)
+nsFontFaceLoader::LoadTimerCallback(nsITimer* aTimer, void* aClosure)
 {
-  nsFontFaceLoader *loader = static_cast<nsFontFaceLoader*>(aClosure);
+  nsFontFaceLoader* loader = static_cast<nsFontFaceLoader*>(aClosure);
 
   if (!loader->mFontSet) {
     // We've been canceled
     return;
   }
 
-  gfxProxyFontEntry *pe = loader->mFontEntry.get();
+  gfxProxyFontEntry* pe = loader->mFontEntry.get();
   bool updateUserFontSet = true;
 
   // If the entry is loading, check whether it's >75% done; if so,
   // we allow another timeout period before showing a fallback font.
   if (pe->mLoadingState == gfxProxyFontEntry::LOADING_STARTED) {
     int64_t contentLength;
     uint32_t numBytesRead;
     if (NS_SUCCEEDED(loader->mChannel->GetContentLength(&contentLength)) &&
@@ -137,18 +137,18 @@ nsFontFaceLoader::LoadTimerCallback(nsIT
     }
   }
 
   // If the font is not 75% loaded, or if we've already timed out once
   // before, we mark this entry as "loading slowly", so the fallback
   // font will be used in the meantime, and tell the context to refresh.
   if (updateUserFontSet) {
     pe->mLoadingState = gfxProxyFontEntry::LOADING_SLOWLY;
-    gfxUserFontSet *fontSet = loader->mFontSet;
-    nsPresContext *ctx = loader->mFontSet->GetPresContext();
+    gfxUserFontSet* fontSet = loader->mFontSet;
+    nsPresContext* ctx = loader->mFontSet->GetPresContext();
     NS_ASSERTION(ctx, "userfontset doesn't have a presContext?");
     if (ctx) {
       fontSet->IncrementGeneration();
       ctx->UserFontSetUpdated();
       LOG(("fontdownloader (%p) timeout reflow\n", loader));
     }
   }
 }
@@ -178,17 +178,17 @@ nsFontFaceLoader::OnStreamComplete(nsISt
            this, fontURI.get()));
     } else {
       LOG(("fontdownloader (%p) download failed - font uri: (%s) error: %8.8x\n", 
            this, fontURI.get(), aStatus));
     }
   }
 #endif
 
-  nsPresContext *ctx = mFontSet->GetPresContext();
+  nsPresContext* ctx = mFontSet->GetPresContext();
   NS_ASSERTION(ctx && !ctx->PresShell()->IsDestroying(),
                "We should have been canceled already");
 
   if (NS_SUCCEEDED(aStatus)) {
     // for HTTP requests, check whether the request _actually_ succeeded;
     // the "request status" in aStatus does not necessarily indicate this,
     // because HTTP responses such as 404 (Not Found) will still result in
     // a success code and potentially an HTML error page from the server
@@ -252,17 +252,17 @@ nsFontFaceLoader::CheckLoadAllowed(nsIPr
                                    nsISupports* aContext)
 {
   nsresult rv;
 
   if (!aSourcePrincipal)
     return NS_OK;
 
   // check with the security manager
-  nsIScriptSecurityManager *secMan = nsContentUtils::GetSecurityManager();
+  nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
   rv = secMan->CheckLoadURIWithPrincipal(aSourcePrincipal, aTargetURI,
                                         nsIScriptSecurityManager::STANDARD);
   if (NS_FAILED(rv)) {
     return rv;
   }
 
   // check content policy
   int16_t shouldLoad = nsIContentPolicy::ACCEPT;
@@ -278,17 +278,17 @@ nsFontFaceLoader::CheckLoadAllowed(nsIPr
 
   if (NS_FAILED(rv) || NS_CP_REJECTED(shouldLoad)) {
     return NS_ERROR_CONTENT_BLOCKED;
   }
 
   return NS_OK;
 }
 
-nsUserFontSet::nsUserFontSet(nsPresContext *aContext)
+nsUserFontSet::nsUserFontSet(nsPresContext* aContext)
   : mPresContext(aContext)
 {
   NS_ASSERTION(mPresContext, "null context passed to nsUserFontSet");
 }
 
 nsUserFontSet::~nsUserFontSet()
 {
   NS_ASSERTION(mLoaders.Count() == 0, "mLoaders should have been emptied");
@@ -305,29 +305,29 @@ void
 nsUserFontSet::Destroy()
 {
   mPresContext = nullptr;
   mLoaders.EnumerateEntries(DestroyIterator, nullptr);
   mRules.Clear();
 }
 
 void
-nsUserFontSet::RemoveLoader(nsFontFaceLoader *aLoader)
+nsUserFontSet::RemoveLoader(nsFontFaceLoader* aLoader)
 {
   mLoaders.RemoveEntry(aLoader);
 }
 
 nsresult
-nsUserFontSet::StartLoad(gfxMixedFontFamily *aFamily,
-                         gfxProxyFontEntry *aProxy,
-                         const gfxFontFaceSrc *aFontFaceSrc)
+nsUserFontSet::StartLoad(gfxMixedFontFamily* aFamily,
+                         gfxProxyFontEntry* aProxy,
+                         const gfxFontFaceSrc* aFontFaceSrc)
 {
   nsresult rv;
 
-  nsIPresShell *ps = mPresContext->PresShell();
+  nsIPresShell* ps = mPresContext->PresShell();
   if (!ps)
     return NS_ERROR_FAILURE;
 
   nsCOMPtr<nsIStreamLoader> streamLoader;
   nsCOMPtr<nsILoadGroup> loadGroup(ps->GetDocument()->GetDocumentLoadGroup());
 
   nsCOMPtr<nsIChannel> channel;
   // get Content Security Policy from principal to pass into channel
@@ -456,38 +456,38 @@ nsUserFontSet::UpdateRules(const nsTArra
     modified = true;
     // Any in-progress loaders for obsolete rules should be cancelled,
     // as the resource being downloaded will no longer be required.
     // We need to explicitly remove any loaders here, otherwise the loaders
     // will keep their "orphaned" font entries alive until they complete,
     // even after the oldRules array is deleted.
     size_t count = oldRules.Length();
     for (size_t i = 0; i < count; ++i) {
-      gfxFontEntry *fe = oldRules[i].mFontEntry;
+      gfxFontEntry* fe = oldRules[i].mFontEntry;
       if (!fe->mIsProxy) {
         continue;
       }
-      gfxProxyFontEntry *proxy = static_cast<gfxProxyFontEntry*>(fe);
-      nsFontFaceLoader *loader = proxy->mLoader;
+      gfxProxyFontEntry* proxy = static_cast<gfxProxyFontEntry*>(fe);
+      nsFontFaceLoader* loader = proxy->mLoader;
       if (loader) {
         loader->Cancel();
         RemoveLoader(loader);
       }
     }
   }
 
   if (modified) {
     IncrementGeneration();
   }
 
   return modified;
 }
 
 void
-nsUserFontSet::InsertRule(nsCSSFontFaceRule *aRule, uint8_t aSheetType,
+nsUserFontSet::InsertRule(nsCSSFontFaceRule* aRule, uint8_t aSheetType,
                           nsTArray<FontFaceRuleRecord>& aOldRules,
                           bool& aFontSetModified)
 {
   NS_ABORT_IF_FALSE(aRule->GetType() == mozilla::css::Rule::FONT_FACE_RULE,
                     "InsertRule passed a non-fontface CSS rule");
 
   // set up family name
   nsAutoString fontfamily;
@@ -595,23 +595,23 @@ nsUserFontSet::InsertRule(nsCSSFontFaceR
   }
 
   // set up src array
   nsTArray<gfxFontFaceSrc> srcArray;
 
   aRule->GetDesc(eCSSFontDesc_Src, val);
   unit = val.GetUnit();
   if (unit == eCSSUnit_Array) {
-    nsCSSValue::Array *srcArr = val.GetArrayValue();
+    nsCSSValue::Array* srcArr = val.GetArrayValue();
     size_t numSrc = srcArr->Count();
     
     for (size_t i = 0; i < numSrc; i++) {
       val = srcArr->Item(i);
       unit = val.GetUnit();
-      gfxFontFaceSrc *face = srcArray.AppendElements(1);
+      gfxFontFaceSrc* face = srcArray.AppendElements(1);
       if (!face)
         return;
 
       switch (unit) {
 
       case eCSSUnit_Local_Font:
         val.GetStringValue(face->mLocalName);
         face->mIsLocal = true;
@@ -684,47 +684,47 @@ nsUserFontSet::InsertRule(nsCSSFontFaceR
       mRules.AppendElement(ruleRec);
     }
     // this was a new rule and fontEntry, so note that the set was modified
     aFontSetModified = true;
   }
 }
 
 void
-nsUserFontSet::ReplaceFontEntry(gfxMixedFontFamily *aFamily,
-                                gfxProxyFontEntry *aProxy,
-                                gfxFontEntry *aFontEntry)
+nsUserFontSet::ReplaceFontEntry(gfxMixedFontFamily* aFamily,
+                                gfxProxyFontEntry* aProxy,
+                                gfxFontEntry* aFontEntry)
 {
   // aProxy is being supplanted by the "real" font aFontEntry, so we need to
   // update any rules that refer to it. Note that there may be multiple rules
   // that refer to the same proxy - e.g. if a stylesheet was loaded multiple
   // times, so that several identical @font-face rules are present.
   for (uint32_t i = 0; i < mRules.Length(); ++i) {
     if (mRules[i].mFontEntry == aProxy) {
       mRules[i].mFontEntry = aFontEntry;
     }
   }
   aFamily->ReplaceFontEntry(aProxy, aFontEntry);
 }
 
 nsCSSFontFaceRule*
-nsUserFontSet::FindRuleForEntry(gfxFontEntry *aFontEntry)
+nsUserFontSet::FindRuleForEntry(gfxFontEntry* aFontEntry)
 {
   for (uint32_t i = 0; i < mRules.Length(); ++i) {
     if (mRules[i].mFontEntry == aFontEntry) {
       return mRules[i].mContainer.mRule;
     }
   }
   return nullptr;
 }
 
 nsresult
-nsUserFontSet::LogMessage(gfxMixedFontFamily *aFamily,
-                          gfxProxyFontEntry *aProxy,
-                          const char        *aMessage,
+nsUserFontSet::LogMessage(gfxMixedFontFamily* aFamily,
+                          gfxProxyFontEntry* aProxy,
+                          const char*        aMessage,
                           uint32_t          aFlags,
                           nsresult          aStatus)
 {
   nsCOMPtr<nsIConsoleService>
     console(do_GetService(NS_CONSOLESERVICE_CONTRACTID));
   if (!console) {
     return NS_ERROR_NOT_AVAILABLE;
   }
@@ -737,17 +737,17 @@ nsUserFontSet::LogMessage(gfxMixedFontFa
     if (aProxy->mSrcList[aProxy->mSrcIndex].mURI) {
       aProxy->mSrcList[aProxy->mSrcIndex].mURI->GetSpec(fontURI);
     } else {
       fontURI.AppendLiteral("(invalid URI)");
     }
   }
 
   char weightKeywordBuf[8]; // plenty to sprintf() a uint16_t
-  const char *weightKeyword;
+  const char* weightKeyword;
   const nsAFlatCString& weightKeywordString =
     nsCSSProps::ValueToKeyword(aProxy->Weight(),
                                nsCSSProps::kFontWeightKTable);
   if (weightKeywordString.Length() > 0) {
     weightKeyword = weightKeywordString.get();
   } else {
     sprintf(weightKeywordBuf, "%u", aProxy->Weight());
     weightKeyword = weightKeywordBuf;
@@ -825,22 +825,22 @@ nsUserFontSet::LogMessage(gfxMixedFontFa
   if (NS_SUCCEEDED(rv)) {
     console->LogMessage(scriptError);
   }
 
   return NS_OK;
 }
 
 nsresult
-nsUserFontSet::CheckFontLoad(const gfxFontFaceSrc *aFontFaceSrc,
-                             nsIPrincipal **aPrincipal,
-                             bool *aBypassCache)
+nsUserFontSet::CheckFontLoad(const gfxFontFaceSrc* aFontFaceSrc,
+                             nsIPrincipal** aPrincipal,
+                             bool* aBypassCache)
 {
   // check same-site origin
-  nsIPresShell *ps = mPresContext->PresShell();
+  nsIPresShell* ps = mPresContext->PresShell();
   if (!ps)
     return NS_ERROR_FAILURE;
 
   NS_ASSERTION(aFontFaceSrc && !aFontFaceSrc->mIsLocal,
                "bad font face url passed to fontloader");
   NS_ASSERTION(aFontFaceSrc->mURI, "null font uri");
   if (!aFontFaceSrc->mURI)
     return NS_ERROR_FAILURE;
@@ -876,20 +876,20 @@ nsUserFontSet::CheckFontLoad(const gfxFo
       }
     }
   }
 
   return rv;
 }
 
 nsresult
-nsUserFontSet::SyncLoadFontData(gfxProxyFontEntry *aFontToLoad,
-                                const gfxFontFaceSrc *aFontFaceSrc,
-                                uint8_t* &aBuffer,
-                                uint32_t &aBufferLength)
+nsUserFontSet::SyncLoadFontData(gfxProxyFontEntry* aFontToLoad,
+                                const gfxFontFaceSrc* aFontFaceSrc,
+                                uint8_t*& aBuffer,
+                                uint32_t& aBufferLength)
 {
   nsresult rv;
 
   nsCOMPtr<nsIChannel> channel;
   // get Content Security Policy from principal to pass into channel
   nsCOMPtr<nsIChannelPolicy> channelPolicy;
   nsCOMPtr<nsIContentSecurityPolicy> csp;
   rv = aFontToLoad->mPrincipal->GetCsp(getter_AddRefs(csp));
@@ -960,17 +960,17 @@ nsUserFontSet::SyncLoadFontData(gfxProxy
   }
 
   return NS_OK;
 }
 
 bool
 nsUserFontSet::GetPrivateBrowsing()
 {
-  nsIPresShell *ps = mPresContext->PresShell();
+  nsIPresShell* ps = mPresContext->PresShell();
   if (!ps) {
     return false;
   }
 
   nsCOMPtr<nsISupports> container = ps->GetDocument()->GetContainer();
   if (!container) {
     return false;
   }
--- a/layout/style/nsFontFaceLoader.h
+++ b/layout/style/nsFontFaceLoader.h
@@ -21,114 +21,114 @@ class nsPresContext;
 class nsIPrincipal;
 
 class nsFontFaceLoader;
 
 // nsUserFontSet - defines the loading mechanism for downloadable fonts
 class nsUserFontSet : public gfxUserFontSet
 {
 public:
-  nsUserFontSet(nsPresContext *aContext);
+  nsUserFontSet(nsPresContext* aContext);
   ~nsUserFontSet();
 
   // Called when this font set is no longer associated with a presentation.
   void Destroy();
 
   // starts loading process, creating and initializing a nsFontFaceLoader obj
   // returns whether load process successfully started or not
-  nsresult StartLoad(gfxMixedFontFamily *aFamily,
-                     gfxProxyFontEntry *aFontToLoad,
-                     const gfxFontFaceSrc *aFontFaceSrc);
+  nsresult StartLoad(gfxMixedFontFamily* aFamily,
+                     gfxProxyFontEntry* aFontToLoad,
+                     const gfxFontFaceSrc* aFontFaceSrc);
 
   // Called by nsFontFaceLoader when the loader has completed normally.
   // It's removed from the mLoaders set.
-  void RemoveLoader(nsFontFaceLoader *aLoader);
+  void RemoveLoader(nsFontFaceLoader* aLoader);
 
   bool UpdateRules(const nsTArray<nsFontFaceRuleContainer>& aRules);
 
-  nsPresContext *GetPresContext() { return mPresContext; }
+  nsPresContext* GetPresContext() { return mPresContext; }
 
-  virtual void ReplaceFontEntry(gfxMixedFontFamily *aFamily,
-                                gfxProxyFontEntry *aProxy,
-                                gfxFontEntry *aFontEntry);
+  virtual void ReplaceFontEntry(gfxMixedFontFamily* aFamily,
+                                gfxProxyFontEntry* aProxy,
+                                gfxFontEntry* aFontEntry);
 
-  nsCSSFontFaceRule *FindRuleForEntry(gfxFontEntry *aFontEntry);
+  nsCSSFontFaceRule* FindRuleForEntry(gfxFontEntry* aFontEntry);
 
 protected:
   // The font-set keeps track of the collection of rules, and their
   // corresponding font entries (whether proxies or real entries),
   // so that we can update the set without having to throw away
   // all the existing fonts.
   struct FontFaceRuleRecord {
     nsRefPtr<gfxFontEntry>       mFontEntry;
     nsFontFaceRuleContainer      mContainer;
   };
 
-  void InsertRule(nsCSSFontFaceRule *aRule, uint8_t aSheetType,
+  void InsertRule(nsCSSFontFaceRule* aRule, uint8_t aSheetType,
                   nsTArray<FontFaceRuleRecord>& oldRules,
                   bool& aFontSetModified);
 
-  virtual nsresult LogMessage(gfxMixedFontFamily *aFamily,
-                              gfxProxyFontEntry *aProxy,
-                              const char *aMessage,
+  virtual nsresult LogMessage(gfxMixedFontFamily* aFamily,
+                              gfxProxyFontEntry* aProxy,
+                              const char* aMessage,
                               uint32_t aFlags = nsIScriptError::errorFlag,
                               nsresult aStatus = NS_OK);
 
-  virtual nsresult CheckFontLoad(const gfxFontFaceSrc *aFontFaceSrc,
-                                 nsIPrincipal **aPrincipal,
-                                 bool *aBypassCache);
+  virtual nsresult CheckFontLoad(const gfxFontFaceSrc* aFontFaceSrc,
+                                 nsIPrincipal** aPrincipal,
+                                 bool* aBypassCache);
 
-  virtual nsresult SyncLoadFontData(gfxProxyFontEntry *aFontToLoad,
-                                    const gfxFontFaceSrc *aFontFaceSrc,
-                                    uint8_t* &aBuffer,
-                                    uint32_t &aBufferLength);
+  virtual nsresult SyncLoadFontData(gfxProxyFontEntry* aFontToLoad,
+                                    const gfxFontFaceSrc* aFontFaceSrc,
+                                    uint8_t*& aBuffer,
+                                    uint32_t& aBufferLength);
 
   virtual bool GetPrivateBrowsing() MOZ_OVERRIDE;
 
-  nsPresContext *mPresContext;  // weak reference
+  nsPresContext* mPresContext;  // weak reference
 
   // Set of all loaders pointing to us. These are not strong pointers,
   // but that's OK because nsFontFaceLoader always calls RemoveLoader on
   // us before it dies (unless we die first).
   nsTHashtable< nsPtrHashKey<nsFontFaceLoader> > mLoaders;
 
   nsTArray<FontFaceRuleRecord>   mRules;
 };
 
 class nsFontFaceLoader : public nsIStreamLoaderObserver
 {
 public:
-  nsFontFaceLoader(gfxMixedFontFamily *aFontFamily,
-                   gfxProxyFontEntry *aFontToLoad, nsIURI *aFontURI, 
-                   nsUserFontSet *aFontSet, nsIChannel *aChannel);
+  nsFontFaceLoader(gfxMixedFontFamily* aFontFamily,
+                   gfxProxyFontEntry* aFontToLoad, nsIURI* aFontURI, 
+                   nsUserFontSet* aFontSet, nsIChannel* aChannel);
 
   virtual ~nsFontFaceLoader();
 
   NS_DECL_ISUPPORTS
   NS_DECL_NSISTREAMLOADEROBSERVER 
 
   // initiate the load
   nsresult Init();
   // cancel the load and remove its reference to mFontSet
   void Cancel();
 
   void DropChannel() { mChannel = nullptr; }
 
-  void StartedLoading(nsIStreamLoader *aStreamLoader);
+  void StartedLoading(nsIStreamLoader* aStreamLoader);
 
-  static void LoadTimerCallback(nsITimer *aTimer, void *aClosure);
+  static void LoadTimerCallback(nsITimer* aTimer, void* aClosure);
 
   static nsresult CheckLoadAllowed(nsIPrincipal* aSourcePrincipal,
                                    nsIURI* aTargetURI,
                                    nsISupports* aContext);
 
 private:
   nsRefPtr<gfxMixedFontFamily> mFontFamily;
   nsRefPtr<gfxProxyFontEntry>  mFontEntry;
   nsCOMPtr<nsIURI>        mFontURI;
   nsRefPtr<nsUserFontSet> mFontSet;
   nsCOMPtr<nsIChannel>    mChannel;
   nsCOMPtr<nsITimer>      mLoadTimer;
 
-  nsIStreamLoader        *mStreamLoader;
+  nsIStreamLoader*        mStreamLoader;
 };
 
 #endif /* !defined(nsFontFaceLoader_h_) */