Funktion vereinfachen, brauche Hilfe

Moin,
Kann man diese Funktion vereinfachen?
Vielen Dank schonmal für eure Hilfe

void SAVE_and_PUT_Handler (int mode)
{
    int address = (int)evaluate_ex();
    word var_position;
    word len;

    if (mode == DO_SAVE)
      address = address % DF_USERSPACE_MAX_LENGTH + DF_USERSPACE_BASE;    

    switch (ReadByteCodeSegByte())
    {
      // Mikes extensions

      case DT_FUNCTION:
      ReadByteCodeSegByte();  // Skip ID_ANSI
      switch (ReadByteCodeSegByte())
      {
        case IK_TIMES:
        {
            char *string = (char*)HEAP_calloc (heap_ptr, 1,STRVAR_DEFAULT_SIZE);
            TIMES_Handler (string);
#ifdef WIN32
            printf ("saving TIME$\n");
#else
            if (mode == DO_SAVE)
              DF_Write (address, (uchar_t*)string, strlen(string));
            else
              LastBasicError = CMD_FWrite (address, (uchar_t*)string, strlen(string));
#endif
            HEAP_free (heap_ptr, string);
        }
        break;

        case IK_DATES:
        {
            char *string = (char*)HEAP_calloc (heap_ptr, 1,STRVAR_DEFAULT_SIZE);
            DATES_Handler (string);
#ifdef WIN32
            printf ("saving DATE$\n");
#else
            if (mode == DO_SAVE)
              DF_Write (address, (uchar_t*)string, strlen(string));
            else
              LastBasicError = CMD_FWrite (address, (uchar_t*)string, strlen(string));
#endif
            HEAP_free (heap_ptr, string);
        }
        break;

      }
      break; // Case DT_FUNCTION

      case DT_FULLARRAY:
      {
         struct arraylist *alp;

         switch (ReadByteCodeSegByte())
         {
           case DT_INTEGER:
           ReadByteCodeSeg (&var_position,2);
           alp = &intarray[var_position];
#ifdef WIN32
           printf ("saving integer array\n");
#else
           if (mode == DO_SAVE)
              DF_Write (address, alp->value, alp->size*sizeof(int));
           else
              LastBasicError = CMD_FWrite (address, alp->value, alp->size*sizeof(int));
#endif
           break;

           case DT_BYTE:
           {
             ReadByteCodeSeg (&var_position,2);
             alp = &intarray[var_position];
#ifdef WIN32
             printf ("saving byte array\n");
#else
             if (mode == DO_SAVE)
                DF_Write (address, alp->value, alp->size);
             else
                LastBasicError = CMD_FWrite (address, alp->value, alp->size);
#endif
           }
           break;
         }
      }
      break;  // DT_FULLARRAY

      case DT_ARRAY:
      {
         int idx;
         int i;
         byte b;

         switch (ReadByteCodeSegByte())
         {
            case DT_INTEGER:
            ReadByteCodeSeg (&var_position,2);
            idx = (int)evaluate_ex();
            i = (int)*((int*)(intarray[var_position].value)+(arrshift[var_position]+idx));
#ifdef WIN32
            printf ("saving integer value from array\n");
#else
            if (mode == DO_SAVE)
              DF_Write (address, (uchar_t*)&i, sizeof(int));
            else
              LastBasicError = CMD_FWrite (address, (uchar_t*)&i, sizeof(int));
#endif
            break;

            case DT_BYTE:
            ReadByteCodeSeg (&var_position,2);
            idx = (int)evaluate_ex();
            b = *((byte*)(intarray[var_position].value)+(arrshift[var_position]+idx));
#ifdef WIN32
            printf ("saving byte value from array\n");
#else
            if (mode == DO_SAVE)
              DF_Write (address, (uchar_t*)&b, 1);
            else
              LastBasicError = CMD_FWrite (address, (uchar_t*)&b, 1);
#endif
            break;
         }
      }
      break;

      case DT_CONST:
      {
         uchar_t b;
         float f;

         switch (ReadByteCodeSegByte())
         {
            case DT_BYTE:
            b = ReadByteCodeSegByte();
#ifdef WIN32
            printf ("saving byte constant: %d\n", b);
#else
            if (mode == DO_SAVE)
              DF_Write (address, &b, 1);
            else
              LastBasicError = CMD_FWrite (address, &b, 1);
#endif
            break;

            case DT_SINGLE:
            ReadByteCodeSeg (&f, 4);            
#ifdef WIN32
            printf ("saving float constant: %f\n", f);
#else
            if (mode == DO_SAVE)
              DF_Write (address, (uchar_t*)&f, 4);
            else
              LastBasicError = CMD_FWrite (address, (uchar_t*)&f, 4);
#endif
            break;
         }
      }
      break;  // case DT_CONST

      case DT_STRING:
         ReadByteCodeSeg (&var_position,2);
         {
            char *string = (char*)HEAP_calloc (heap_ptr, 1,STRVAR_DEFAULT_SIZE);
            len = (word)strlen(charstack[var_position]);
            strncpy(string, charstack[var_position], len+1);
#ifdef WIN32
            printf ("saving string constant\n");

#else
            if (mode == DO_SAVE)
              DF_Write (address, (uchar_t*)string, strlen(string));
            else
              LastBasicError = CMD_FWrite (address, (uchar_t*)string, strlen(string));
#endif
            HEAP_free (heap_ptr, string);
         }
         break;

      case DT_SINGLE:
          ReadByteCodeSeg (&var_position,2);
          {
            float single_num = (float)*intstack[var_position];
#ifdef WIN32
            printf ("saving float variable\n");
#else
            if (mode == DO_SAVE)
              DF_Write (address, (uchar_t*)&single_num, 4);
            else
              LastBasicError = CMD_FWrite (address, (uchar_t*)&single_num, 4);
#endif
          }
          break;
   }
}

CStoll

Gegenfrage: Was soll die Funktion überhaupt machen?

Auf jeden Fall könntest du die ständig gleichen Blöcke "if(mode==do_save)...else..." aus dem gewaltigen switch() auslagern oder in eine Unterfunktion packen. Und die "#ifdef WIN32" Abschnitte sehen auch nach einer Notlösung aus.

Danke, CStoll. Das Auslagern der Schreibfunktion ist schon mal eine sehr gute Idee!!!
Die Funktion ist Teil einer Virtual Machine. Sie speichert Variablen und Konstanten entweder auf eine SD-Karte oder in einen fest angeschlossenen Flash-Speicher.
Läßt sich noch was vereinfachen?

Die WIN32 Abschnitte sind nur zum Debuggen. Der Code läuft auf einem Embedded System.

CStoll

Fred vom Jupiter schrieb:

Sie speichert Variablen und Konstanten entweder auf eine SD-Karte oder in einen fest angeschlossenen Flash-Speicher.

Und auf Windows-Systemen gibt es keins von beidem? oder was sollen die "#ifdef WIN32"-Blöcke bewirken?

btw - was auffällt ist, daß du anscheinend viel mit globalen Daten arbeitest. Dadurch geht einiges an Struktur verloren.

CStoll schrieb:

Fred vom Jupiter schrieb:

Sie speichert Variablen und Konstanten entweder auf eine SD-Karte oder in einen fest angeschlossenen Flash-Speicher.

Und auf Windows-Systemen gibt es keins von beidem? oder was sollen die "#ifdef WIN32"-Blöcke bewirken?

Unter Windows möchte ich nur sehen ob die Funktion richtig verzweigt. Ist nur eine Debugging-Hilfe.

CStoll schrieb:

btw - was auffällt ist, daß du anscheinend viel mit globalen Daten arbeitest. Dadurch geht einiges an Struktur verloren.

Ja. Aber das sind Daten, die Ich überall in dem Modul brauche. Sollte ich die an die verschiedenen Funktionen übergeben? Würde das den Code nicht aufblähen?