📋 Instructions: DNA and Phylogenetic Trees in C

The objective of this project is to define and manipulate data structures in C to represent DNA sequences and phylogenetic trees.

Part 1: Type Definitions (dna.h File)

• nucleo Type
  Define a type nucleo that can take the values A, T, G, or C. (Note: you are asked to define these four values, not to work with a simple char).
• dna_t Type
  Define a type dna_t containing:
  • A code pointer to a nucleo (which will correspond to an array of nucleo).
  • An integer size (which will correspond to the size of this array).
• tree_t Type (Phylogenetic Trees)
  We will now define phylogenetic trees (a type of family tree).
  Such a tree can either contain a pointer to a dna_t (a leaf), or two pointers to other such trees (a node).
  Define a type tree_t containing:
  • A boolean isaleaf (indicating whether it is a leaf or not).
  • A content field (a union) which can contain, either:
    • A pair of pointers to tree_t.
    • Or a pointer to a dna_t.

Part 2: Function Implementation (dna.c File)

You must implement the following functions (prototyped in dna.h).

2.1 Memory Management (DNA)

• dna_t* createdna(int size)
  Given a strictly positive integer size, allocate space for a dna_t of that size, including the space for the code array.
  Returns the address of the newly reserved space.
  In case of error, any potentially allocated memory must be freed correctly, and the function must return NULL.
• void freedna(dna_t* d)
  Frees the space allocated by createdna.
  It must be able to free the space even if not all of it was allocated correctly (e.g., if d is non-null but d->code is null).

2.2 Memory Management (Trees)

• tree_t* makeNode(tree_t* t1, tree_t* t2)
  Creates a node (non-leaf) from two subtrees t1 and t2.
  Returns the address of the newly reserved space.
  In case of error (e.g., if t1 or t2 is NULL), any potentially allocated memory must be freed, and the function must return NULL.
• tree_t* makeLeaf(dna_t* d)
  Creates a leaf containing the dna_t d.
  Returns the address of the newly reserved space.
  In case of error (e.g., if d is NULL), any potentially allocated memory must be freed, and the function must return NULL.
• void freetree(tree_t* t)
  Frees the space allocated for a tree t.
  It must recursively free the space of sub-structures (nodes and leaves), calling freedna when necessary.
  Must work even if the tree is only partially allocated.

2.3 Utility Functions

• int distdna (dna_t* d1, dna_t* d2)
  Calculates the distance between two dna_t.
  • Definition: The number of nucleotides that differ between the two.
  • Rules:
    • The alignment is done on the first nucleotide (compare index 0 with 0, 1 with 1, etc.).
    • An absence of a nucleotide (if one sequence is shorter) differs from any nucleotide.
  • Example: ATAGCAG and ATCGC have a distance of 3 (one for A vs C at the 3rd index, and two for the last two missing nucleotides).
  • In case of error, return -1.
• dna_t* readdna (FILE* f)
  Reads the next two lines from a file Tf.
  Expected format:
  1. A line with only an integer (the size of the code).
  2. A line with the nucleotides (e.g., ATTATCG), without separation.
  The function must allocate the necessary space for the corresponding dna_t and fill it with the read data.
  In case of error, return NULL.

Part 3: Main Program (main Function)

Write a main function that adheres to the following instructions:

• The program is called with a filename as an argument (argv[1]).
• It must open the specified file.
• It must read all DNA codes contained in the file (using readdna).
• It must build a tree (tree_t) (of any form you like) with these codes.
• From this tree, the program must calculate the distance of each of these codes to the reference code: "TATGCTTG".
• It must print these distances (to standard output).
• In case of error (file opening, reading, etc.), the program must write an error message to standard error (stderr).
• Take special care to free all used memory before terminating.