Subversion Repositories pentevo

Rev

Blame | Last modification | View Log | Download | RSS feed | ?url?

  1. /* cpulist.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Port                                                                   */
  6. /*                                                                           */
  7. /* Manages CPU List                                                          */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include <string.h>
  13. #include <ctype.h>
  14. #include "strutil.h"
  15.  
  16. #include "cpulist.h"
  17.  
  18. static tpCPUDef FirstCPUDef;                   /* Liste mit Prozessordefinitionen */
  19. static CPUVar CPUCnt;                          /* Gesamtzahl Prozessoren */
  20. static int MaxNameLen = 0;
  21.  
  22. /****************************************************************************/
  23. /* neuen Prozessor definieren */
  24.  
  25. CPUVar AddCPUUserWithArgs(const char *NewName, tCPUSwitchUserProc Switcher, void *pUserData, tCPUFreeUserDataProc Freeer, const tCPUArg *pArgs)
  26. {
  27.   tpCPUDef Lauf, Neu;
  28.   char *p;
  29.   int l;
  30.  
  31.   Neu = (tpCPUDef) malloc(sizeof(tCPUDef));
  32.   Neu->Name = as_strdup(NewName);
  33.   Neu->pArgs = pArgs;
  34.   /* kein UpString, weil noch nicht initialisiert ! */
  35.   for (p = Neu->Name; *p != '\0'; p++)
  36.     *p = as_toupper(*p);
  37.   Neu->SwitchProc = Switcher;
  38.   Neu->FreeProc = Freeer;
  39.   Neu->pUserData = pUserData;
  40.   Neu->Next = NULL;
  41.   Neu->Number = Neu->Orig = CPUCnt;
  42.  
  43.   l = strlen(NewName);
  44.   if (l > MaxNameLen)
  45.     MaxNameLen = l;
  46.  
  47.   Lauf = FirstCPUDef;
  48.   if (!Lauf)
  49.     FirstCPUDef = Neu;
  50.   else
  51.   {
  52.     while (Lauf->Next)
  53.       Lauf = Lauf->Next;
  54.     Lauf->Next = Neu;
  55.   }
  56.  
  57.   return CPUCnt++;
  58. }
  59.  
  60. typedef struct
  61. {
  62.   tCPUSwitchProc Switcher;
  63. } tNoUserData;
  64.  
  65. static void SwitchNoUserProc(void *pUserData)
  66. {
  67.   ((tNoUserData*)pUserData)->Switcher();
  68. }
  69.  
  70. static void FreeNoUserProc(void *pUserData)
  71. {
  72.   free(pUserData);
  73. }
  74.  
  75. CPUVar AddCPUWithArgs(const char *NewName, tCPUSwitchProc Switcher, const tCPUArg *pArgs)
  76. {
  77.   tNoUserData *pData = (tNoUserData*)malloc(sizeof(*pData));
  78.  
  79.   pData->Switcher = Switcher;
  80.   return AddCPUUserWithArgs(NewName, SwitchNoUserProc, pData, FreeNoUserProc, pArgs);
  81. }
  82.  
  83. Boolean AddCPUAlias(char *OrigName, char *AliasName)
  84. {
  85.   tpCPUDef Lauf = FirstCPUDef, Neu;
  86.  
  87.   while ((Lauf) && (strcmp(Lauf->Name, OrigName)))
  88.     Lauf = Lauf->Next;
  89.  
  90.   if (!Lauf)
  91.     return False;
  92.   else
  93.   {
  94.     Neu = (tpCPUDef) malloc(sizeof(tCPUDef));
  95.     Neu->Next = NULL;
  96.     Neu->Name = as_strdup(AliasName);
  97.     Neu->Number = CPUCnt++;
  98.     Neu->Orig = Lauf->Orig;
  99.     Neu->SwitchProc = Lauf->SwitchProc;
  100.     Neu->FreeProc = Lauf->FreeProc;
  101.     Neu->pUserData = Lauf->pUserData;
  102.     Neu->pArgs = Lauf->pArgs;
  103.     while (Lauf->Next)
  104.       Lauf = Lauf->Next;
  105.     Lauf->Next = Neu;
  106.     return True;
  107.   }
  108. }
  109.  
  110. void IterateCPUList(tCPUListIterator Iterator, void *pUser)
  111. {
  112.   tpCPUDef pRun;
  113.  
  114.   for (pRun= FirstCPUDef; pRun; pRun = pRun->Next)
  115.     Iterator(pRun, pUser);
  116. }
  117.  
  118. typedef struct
  119. {
  120.   int cnt, perline;
  121.   tCPUSwitchUserProc Proc;
  122.   tCPUSwitchProc NoUserProc;
  123.   tPrintLineCPUProc PrintProc;
  124.   String line_buffer;
  125. } tPrintContext;
  126.  
  127. static void PrintIterator(const tCPUDef *pCPUDef, void *pUser)
  128. {
  129.   tPrintContext *pContext = (tPrintContext*)pUser;
  130.  
  131.   /* ignore aliases */
  132.  
  133.   if (pCPUDef->Number == pCPUDef->Orig)
  134.   {
  135.     tCPUSwitchProc ThisNoUserProc = (pCPUDef->SwitchProc == SwitchNoUserProc) ? ((tNoUserData*)pCPUDef->pUserData)->Switcher : NULL;
  136.     Boolean Unequal;
  137.  
  138.     if (pCPUDef->SwitchProc != pContext->Proc)
  139.       Unequal = True;
  140.     else if (pCPUDef->SwitchProc == SwitchNoUserProc)
  141.       Unequal = (pContext->NoUserProc != ThisNoUserProc);
  142.     else
  143.       Unequal = False;
  144.     if (Unequal || (pContext->cnt == pContext->perline))
  145.     {
  146.       pContext->Proc = pCPUDef->SwitchProc;
  147.       pContext->NoUserProc = ThisNoUserProc;
  148.       pContext->PrintProc(pContext->line_buffer);
  149.       pContext->cnt = 0;
  150.       pContext->line_buffer[0] = '\0';
  151.     }
  152.     as_snprcatf(pContext->line_buffer, sizeof(pContext->line_buffer), "%-*s", MaxNameLen + 1, pCPUDef->Name);
  153.     pContext->cnt++;
  154.   }
  155. }
  156.  
  157. void PrintCPUList(tPrintLineCPUProc PrintProc)
  158. {
  159.   tPrintContext Context;
  160.  
  161.   Context.Proc = NULL;
  162.   Context.NoUserProc = NULL;
  163.   Context.cnt = 0;
  164.   Context.line_buffer[0] = '\0';
  165.   Context.PrintProc = PrintProc;
  166.   Context.perline = 79 / (MaxNameLen + 1);
  167.   IterateCPUList(PrintIterator, &Context);
  168.   PrintProc("");
  169. }
  170.  
  171. void ClearCPUList(void)
  172. {
  173.   tpCPUDef Save;
  174.  
  175.   while (FirstCPUDef)
  176.   {
  177.     Save = FirstCPUDef;
  178.     FirstCPUDef = Save->Next;
  179.     free(Save->Name);
  180.     if (Save->FreeProc)
  181.       Save->FreeProc(Save->pUserData);
  182.     free(Save);
  183.   }
  184. }
  185.  
  186. const tCPUDef *LookupCPUDefByVar(CPUVar Var)
  187. {
  188.   tpCPUDef pRun;
  189.  
  190.   for (pRun = FirstCPUDef; pRun; pRun = pRun->Next)
  191.     if (pRun->Number == Var)
  192.       break;
  193.   return pRun;
  194. }
  195.  
  196. const tCPUDef *LookupCPUDefByName(const char *pName)
  197. {
  198.   tpCPUDef pRun;
  199.  
  200.   for (pRun = FirstCPUDef; pRun; pRun = pRun->Next)
  201.   {
  202.     int l = strlen(pRun->Name);
  203.  
  204.     if (strncmp(pRun->Name, pName, l))
  205.       continue;
  206.     if ((pName[l] == '\0') || (pName[l] == ':'))
  207.       break;
  208.   }
  209.   return pRun;
  210. }
  211.  
  212. void cpulist_init(void)
  213. {
  214.   FirstCPUDef = NULL;
  215.   CPUCnt = 0;
  216. }
  217.