// Please helps to answer a correct one thanks //Complete the missing source cod

Question

// Please helps to answer a correct one thanks

//Complete the missing source code - - -
#include <stdlib.h>
#include <string.h>
#include "myalloc.h"

/*
Given a dynamically allocated array of dynamically allocated
strings like in the preceding problem, convert to one long
(dynamically allocated) string, separating entries by spaces.
For example, flatten(heads("Hello")) returns "H He Hel Hell Hello".
*/
char *flatten(char **strings, int nstrings)
{
   - - -
}
//////////////////////////////////////////////////////////////////////////////
//Use the following files:
//Tester.c
#include <stdio.h>
#include <string.h>
#include <stdarg.h>

#include "myalloc.h"

char *flatten(char **strings, int nstrings);

char** strings(int count, ...)
{
   int i;
   char** result = my_malloc(count * sizeof(char*));
   va_list argp;
   va_start(argp, count);
   for (i = 0; i < count; i++) {
      char* str = va_arg(argp, char*);
      result[i] = my_malloc(strlen(str) + 1);
      strcpy(result[i], str);
   }
   va_end(argp);
   return result;
}
  
int main() {
   char* result = flatten(strings(3, "Goodbye", "cruel", "world"), 3);
   printf("%s ", result);
   printf("Expected: Goodbye cruel world ");
   printf("Size: %d ", my_size(result));
   printf("Expected: 20 ");
   my_free(result);
  
   char* result2 = flatten(strings(5, "H", "He", "Hel", "Hell", "Hello"), 5);
   printf("%s ", result2);
   printf("Expected: H He Hel Hell Hello ");
   my_free(result2);
   printf("Allocated: %d ", my_allocated());
   printf("Expected: 0 ");  
   return 0;
}

myalloc.c
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>

#define POOL_SIZE 100000
#define HEADER_SIZE (2 * sizeof(int))

static unsigned char pool[POOL_SIZE];
static unsigned char *pool_end = pool;
static int allocated = 0;

void* my_malloc(int size)
{
   if (pool == pool_end) { // first time
      for (int i = 0; i < POOL_SIZE; i++)
         pool[i] = 0xDB;
   }
  
   unsigned char *result = NULL;
   if (pool_end + HEADER_SIZE + size <= pool + POOL_SIZE) {
      int* header = (int*) pool_end;
      if (header[0] == 0xDBDBDBDB) { // else corrupted
         unsigned char *contents = pool_end + HEADER_SIZE;
     
         result = contents;
         pool_end = pool_end + HEADER_SIZE + size;
         header[0] = 0xBEEFBEEF;
         header[1] = size;
         while (size-- > 0) *contents++ = 0xBB;
         allocated++;
      }
      else
         fprintf(stderr, "Pool corrupted ");
   }
   return result;
}

void my_free(void *p)
{
   unsigned char *contents = (unsigned char *) p;
   if (pool <= contents - HEADER_SIZE && contents < pool_end) {
      int* header = (int *)(contents - HEADER_SIZE);
      if (header[0] == 0xBEEFBEEF) {
         int size = header[1];
         if (0 <= size && size <= pool_end - contents) {
            header[0] = 0xDEADBEEF;
            while (size-- > 0) *contents++ = 0xDB;
            allocated--;
         }
      }
   }
   else
      fprintf(stderr, "Bad free ");
}

int my_size(void *p) {
   unsigned char *contents = (unsigned char *) p;
   if (pool <= contents - HEADER_SIZE && contents < pool_end) {     
      int* header = (int *)(contents - HEADER_SIZE);
      if (header[0] == 0xBEEFBEEF) {
         int size = header[1];
         if (0 <= size && size <= pool_end - contents)
            return size;
      }
   }
   return -1;
}

static bool pool_corrupted() {
   unsigned char *p = pool;
   while (p < pool_end) {
      int *header = (int *) p;
      unsigned char *contents = p + HEADER_SIZE;
      int size = header[1];
      if (header[0] != 0xBEEFBEEF && header[0] != 0xDEADBEEF)
         return true;
      if (size < 0 || size > pool_end - contents) return true;
      p = contents + size;
      if (header[0] == 0xDEADBEEF) {
         while (size-- > 0) {
            if (*contents++ != 0xDB) return false;
         }
      }
   }
   while (p < pool + POOL_SIZE)
      if (*p++ != 0xDB)
         return false;
     
   return false;
}

int my_allocated() {
   if (pool_corrupted()) return -1;
   else return allocated;
}

myalloc.h
#include <stdbool.h>

void* my_malloc(int size);
void my_free(void *p);
int my_allocated(); // number of allocated blocks or -1 if pool corrupted
int my_size(void *p); // size of p or -1 if not if allocated
// by this allocator or if corrupted

Explanation / Answer

Please find the below code: #include #include #include char ** stutterString(char *str) { int i, sz, len=strlen(str); char **rtn; /* a 2-dimensional array */ char *s; /* allocate the number of rows plus an extra one to indicate the end of list. calloc() will set all "rows" to NULL. */ rtn = (char **)calloc(len+1, sizeof(char **)); for(i=0; i

Related Questions

Navigate

• Browse (All)
• Browse #
• Subjects

---

---

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.