Come presentare il codice nel lavoro accademico?

In realtà, sto scrivendo la mia tesi di laurea, che consiste nell'analizzare l'algoritmo BitTorrent e vedere la sua applicazione su Client di trasmissione come esempio di implementazione .

Leggendo il suo codice, scritto in C, puoi vedere molti livelli di funzioni

static const char*
tr_metainfoParseImpl (const tr_session  * session,
                      tr_info           * inf,
                      bool              * hasInfoDict,
                      int               * infoDictLength,
                      const tr_variant     * meta_in)
{
  int64_t i;
  size_t len;
  const char * str;
  const uint8_t * raw;
  tr_variant * d;
  tr_variant * infoDict = NULL;
  tr_variant * meta = (tr_variant *) meta_in;
  bool b;
  bool isMagnet = false;

  /* info_hash: urlencoded 20-byte SHA1 hash of the value of the info key
   * from the Metainfo file. Note that the value will be a bencoded
   * dictionary, given the definition of the info key above. */
  b = tr_variantDictFindDict (meta, TR_KEY_info, &infoDict);
  if (hasInfoDict != NULL)
    *hasInfoDict = b;

  if (!b)
    {
      /* no info dictionary... is this a magnet link? */
      if (tr_variantDictFindDict (meta, TR_KEY_magnet_info, &d))
        {
        (...)

tr_metainfoParseImpl() è la funzione chiamata dopo aver aggiunto un .torrent per file o link magnete. Chiama tr_variantDictFindDict() per trovare qualche stringa "info" da qualche parte nel dizionario dei metadati, in modo da ottenere informazioni su quel file torrent.

Algoritmicamente, non ha alcun valore per me, dal momento che voglio enfatizzare altri aspetti dell'algoritmo BitTorrent oltre alla ricerca stringa, anche se voglio lasciare la sua linea di chiamata solo per illustrare che è felice.

La funzione tr_variantDictFindDict() e il suo figlio sono

bool // func1
tr_variantDictFindDict (tr_variant       * dict,
                        const tr_quark     key,
                        tr_variant      ** setme)
{
  return tr_variantDictFindType (dict, key, TR_VARIANT_TYPE_DICT, setme);
}

static bool // func2
tr_variantDictFindType (tr_variant      * dict,
                        const tr_quark    key,
                        int               type,
                        tr_variant     ** setme)
{
  return tr_variantIsType (*setme = tr_variantDictFind (dict, key), type);
}

Come possiamo vedere, sebbene ciò possa esistere per ragioni di ingegneria del codice, algoritmicamente non ha alcun valore.

Quindi, sto cercando modi ragionevoli, fattibili e pratici per evitare di mostrare questo tipo di codice nel mio lavoro.

Usando il codice sopra come esempio, ho pensato ad alcune opzioni:

1. metti la parte rilevante della funzione chiamante func1, mostrando la funzione di chiamata di linea1, e dopo quella mostra func2 callee (in cui avrà l'altra parte rilevante del codice.

2. inserendo il codice del chiamante func1 e il func2 callee "side by side", come se fossero in un'unica grande funzione

3. programmazione alfabetica dall'inizio

Per favore, sentiti libero di condividere le tue esperienze con questa situazione. Inoltre, si prega di cambiare il sito SX, se necessario, anche se ho cercato il miglior sito SX per porre questa domanda e questo sembrava legittimo.