C++ (Cpp) E_StringForName Examples

Example #1

File: e_string.cpp Project: doomtech/eternity

//
// E_GetStringForName
//
// As above, but causes an error if the string doesn't exist.
//
edf_string_t *E_GetStringForName(const char *key)
{
   edf_string_t *str = E_StringForName(key);

   if(!str)
      I_Error("E_GetStringForName: no such string '%s'\n", key);

   return str;
}

Example #2

File: e_string.cpp Project: doomtech/eternity

//
// E_CreateString
//
// Creates an EDF string object with the given value which is hashable
// by one or two different keys. The mnemonic key is required and must
// be 128 or fewer characters long. The numeric key is optional. If a
// negative value is passed as the numeric key, the object will not be 
// added to the numeric hash table.
//
edf_string_t *E_CreateString(const char *value, const char *key, int num)
{
   int keyval;
   edf_string_t *newStr;

   if((newStr = E_StringForName(key)))
   {
      // Modify existing object.
      E_ReplaceString(newStr->string, estrdup(value));

      // Modify numeric id and rehash object if necessary
      if(num != newStr->numkey)
      {
         // If old key is >= 0, must remove from hash first
         if(newStr->numkey >= 0)
            E_DelStringFromNumHash(newStr);
         
         // Set new key
         newStr->numkey = num;
         
         // If new key >= 0, add back to hash
         if(newStr->numkey >= 0)
            E_AddStringToNumHash(newStr);
      }
   }
   else
   {
      // Create a new string object
      newStr = estructalloc(edf_string_t, 1);
      
      // copy keys into string object
      if(strlen(key) >= sizeof(newStr->key))
      {
         E_EDFLoggedErr(2, 
            "E_CreateString: invalid string mnemonic '%s'\n", key);
      }
      strncpy(newStr->key, key, sizeof(newStr->key));
      
      newStr->numkey = num;
      
      // duplicate value
      newStr->string = estrdup(value);
      
      // add to hash tables
      
      keyval = D_HashTableKey(newStr->key) % NUM_EDFSTR_CHAINS;
      newStr->next = edf_str_chains[keyval];
      edf_str_chains[keyval] = newStr;
      
      // numeric key is not required
      if(num >= 0)
         E_AddStringToNumHash(newStr);
   }

   return newStr;
}

Example #3

File: hi_stuff.cpp Project: Altazimuth/eternity

static void HI_loadData(void)
{
   int i;
   char mapname[9];

   memset(mapname, 0, 9);

   // load interpic
   hi_interpic = NULL;
   hi_exitpic = nullptr;

   if(estrnonempty(hi_wbs.li_lastexitpic))
   {
      hi_exitpic = PatchLoader::CacheName(wGlobalDir, hi_wbs.li_lastexitpic,
                                          PU_STATIC);
   }

   if(estrnonempty(hi_wbs.li_nextenterpic))
   {
      hi_interpic = PatchLoader::CacheName(wGlobalDir, hi_wbs.li_nextenterpic,
                                           PU_STATIC);
   }
   else if(gameepisode <= 3)
   {
      sprintf(mapname, "MAPE%d", gameepisode);
      hi_interpic = PatchLoader::CacheName(wGlobalDir, mapname, PU_STATIC);
   }

   // load positional indicators
   hi_in_x   = PatchLoader::CacheName(wGlobalDir, "IN_X",   PU_STATIC);
   hi_in_yah = PatchLoader::CacheName(wGlobalDir, "IN_YAH", PU_STATIC);

   // get lump numbers for faces
   for(i = 0; i < 4; i++)
   {
      char tempstr[9];

      memset(tempstr, 0, 9);

      sprintf(tempstr, "FACEA%.1d", i);
      hi_faces[i] = W_GetNumForName(tempstr);

      sprintf(tempstr, "FACEB%.1d", i);
      hi_dead_faces[i] = W_GetNumForName(tempstr);
   }

   // haleyjd 03/27/05: EDF-defined intermission map names
   mapName     = NULL;
   nextMapName = NULL;

   {
      char nameBuffer[24];
      const char *basename;
      edf_string_t *str;

      // set current map
      if(hi_wbs.li_lastlevelname && *hi_wbs.li_lastlevelname)
         mapName = hi_wbs.li_lastlevelname;
      else
      {
         psnprintf(nameBuffer, 24, "_IN_NAME_%s", gamemapname);
         if((str = E_StringForName(nameBuffer)))
            mapName = str->string;
      }

      if(hi_wbs.li_nextlevelname && *hi_wbs.li_nextlevelname)
      {
         nextMapName = hi_wbs.li_nextlevelname;
         return;
      }

      // are we going to a secret level?
      basename = hi_wbs.gotosecret ? LevelInfo.nextSecret : LevelInfo.nextLevel;

      // set next map
      if(*basename)
      {
         psnprintf(nameBuffer, 24, "_IN_NAME_%s", basename);

         if((str = E_StringForName(nameBuffer)))
            nextMapName = str->string;
      }
      else
      {
         // try ExMy and MAPxy defaults for normally-named maps
         if(isExMy(gamemapname))
         {
            psnprintf(nameBuffer, 24, "_IN_NAME_E%01dM%01d", 
                      hi_wbs.epsd + 1, hi_wbs.next + 1);
            if((str = E_StringForName(nameBuffer)))
               nextMapName = str->string;
         }
         else if(isMAPxy(gamemapname))
         {
            psnprintf(nameBuffer, 24, "_IN_NAME_MAP%02d", hi_wbs.next + 1);
            if((str = E_StringForName(nameBuffer)))
               nextMapName = str->string;
         }
      }
   }
}