[IDC] Tiny script automatically naming ~300 functions by parsing debug strings

void LogActionf(const char *szFormat, ...);

LT ERROR: %s returned %s (%s)

#include <idc.idc>

static main()
{
   auto  strAddr     = LocByName("pLtErrorSReturn"), 
         logFunAddr  = LocByName("LogActionf"), 
         curXref, 
         curAddr,
         curTraceAddr,
         firstParamFound,
         funcNameStrAddr,
         regId,
         funAddr,
         funName,
         oldFunName;
      
   for(curXref = DfirstB(strAddr)
      ; curXref != BADADDR
      ; curXref = DnextB(strAddr, curXref))
   {
      // locate function name
      // ------------------------------------------------
   
      // Check mnemonic
      if (GetMnem(curXref) != "mov" 
         || GetOpType(curXref, 0) != o_reg
         || GetOpType(curXref, 1) != o_mem)
      {
         Message("[0x%08X] referencing instruction is not \"mov eXx, [mem]\"!\n", curXref);
         continue;
      }
      
      // Find LogActionf call (max 50 bytes away)
      for (curAddr = curXref
         ; curAddr != BADADDR
         ; curAddr = NextAddr(curAddr))
      {
         // Is call to log fun? Break loop
         if (GetMnem(curAddr) == "call" 
            && GetOpnd(curAddr, 0) == "LogActionf")
         {
            break;
         }
         
         if (curAddr - curXref > 50)
         {
            Message("[0x%08X] too many steps till LogActionf call\n", curXref);
            return;
         }
      }
      
      // Find LogActionf's second parameter
      for (firstParamFound = 0; curAddr != BADADDR; curAddr = PrevAddr(curAddr))
      {
         // Conditional?
         if (RfirstB0(curAddr) != BADADDR)
         {
            Message("[0x%08X] conditional situation\n", curAddr);
            break;
         }
         
         // Desired parameter?
         if (GetMnem(curAddr) == "push")
         {
            if (!firstParamFound)
               firstParamFound = 1;
            else
            {
               funcNameStrAddr = 0;
            
               // In case the operand is a register, we have to trace what
               // is written into it
               if (GetOpType(curAddr, 0) == o_reg)
               {
                  regId = GetOperandValue(curAddr, 0);
                                    
                  for (curTraceAddr = curAddr
                     ; curTraceAddr != BADADDR
                     ; curTraceAddr = PrevAddr(curTraceAddr))
                  {
                     // Does instruction write into our register?
                     if (GetOpType(curTraceAddr, 0) == o_reg
                        && GetOperandValue(curTraceAddr, 0) == regId
                        && GetOpType(curTraceAddr, 1) == o_mem)
                     {
                        funcNameStrAddr = Dword(GetOperandValue(curTraceAddr, 1));
                        break;
                     }
                     
                     // Max. trace distance = 50 non-conditional bytes
                     if (curAddr - curTraceAddr > 50 || RfirstB0(curTraceAddr) != BADADDR)
                     {
                        Message("[0x%08X] conditional situation or trace width exceeded\n", 
                                curTraceAddr);
                        break;
                     }
                  }
               } 
               else if (GetOpType(curAddr, 0) == o_imm)
                  funcNameStrAddr = GetOperandValue(curAddr, 0);
               else
               {
                  Message("[0x%08X] unsupported operand\n", curAddr);
                  return;
               }
               
               // check if string contains spaces (filter out names with comments)
               funName = 0;
               if (funcNameStrAddr)
               {
                  if (strstr(GetString(funcNameStrAddr, -1, ASCSTR_C), " ") != -1)
                  {
                     Message("[0x%08X] no valid function name\n", curAddr);
                     funcNameStrAddr = 0;
                  }
                  else
                     funName = GetString(funcNameStrAddr, -1, ASCSTR_C);
               }
                  
               break;
            }
         }
      }
      
      // rename function
      // ------------------------------------------------
      
      // only if function's name could be determined
      if (funName)
      {   
         oldFunName = GetFunctionName(curXref);
         
         if (oldFunName != "" && !hasName(GetFlags(LocByName(oldFunName))))
         {
            // make name unique
            while (LocByName(funName) != BADADDR)
               funName = funName + "_";
         
            Message("[0x%08X] %s => %s\n", LocByName(oldFunName), oldFunName, funName);
            MakeNameEx(LocByName(oldFunName), funName, SN_CHECK | SN_NON_AUTO);
         }
      }
      
      // ------------------------------------------------
      
   }
   
   Message("Done, leaving.\n");
} // ==> main