void file_reverse_output(FILE * file,
                         FILE * newfile,
                         char * type)
{
  // we don't check newfile as NULL is a valid value
  assert(file);

  // declare & initialize
  long int len = file_num_lines(file);
  long int maxstr = 0;

  if (string_is_valid(type, "memsave")) {
    maxstr = file_longest_string(file);
    printf("memsave active\n");
  } else if (string_is_valid(type, "nomemsave")) {
    // this section fails assertion on file at getline_mem_alloc
    // below
    maxstr = MAX_BUFFER;
    printf("standard buffer active\n");
  } else {
    printf("specify memsave / nomemsave\n");
    exit(1);
  }

  char buffer[len][maxstr + 1];
  // initialize array. this solved an uninitialized value
  // error in valgrind down in the print loop. there may
  // be a better way to solve the error. this isn't the
  // fastest i'm guessing
  for (int i = 0; i <= len; i++) {
    for (int j = 0; j <= maxstr; j++) {
      buffer[i][j] = '\0';
    }
  }

  // loop through each line in text file, put in buffer for
  // future stdout / fprintf
  for (int i = 0; i < len; i++) {
    char * ptr = getline_mem_alloc(file);
    if (!ptr) {
      break;
    }
    // load lines into buffer and clear pointer
    strncpy(buffer[i],
            ptr,
            maxstr - 1);
    clear_char_ptr(ptr);
  }

  // reset file for next usage
  rewind(file);

  // print buffer in reverse order to either stdout or newfile
  for (int j = len - 1; j >= 0; j--) {
    no_more_newline(buffer[j]);
    if (newfile == NULL) {
      printf("%s\n",
             buffer[j]);
    } else {
      fprintf(newfile,
              "%s\n",
              buffer[j]);
    }
  }

  // rewind temp for next usage
  if (newfile) {
    rewind(newfile);
  }
}

#include <stdio.h>
#include <jmgeneral.h>
#include <string.h>

int main()
{
  FILE * file = fopen("testfile.txt", "r");
  if (!file) {
    printf("failed to open\n");
    return(1);
  }
  // this one works fine
  file_reverse_output(file, NULL, "memsave");
  // this run fails file assertion when it gets to 
  // getline function in file_reverse_output
  file_reverse_output(file, NULL, "nomemsave");
  fclose(file);
  file = NULL;
  return(0);
}

if (string_is_valid(type, "memsave")) {
    // works when run longest string on file
    maxstr = file_longest_string(file);

  } else if (string_is_valid(type, "nomemsave")) {
    // doesn't work with static buffer number...
    maxstr = MAX_BUFFER;

  } else {
    printf("specify memsave / nomemsave\n");
    exit(1);
  }

long int file_longest_string(FILE * file, long int lines)
{
  assert(file);

  // declare & initialize
  long int len = 0;

  // loop through each line in file.
  // set return value to longest string in file
  for (int i = 0; i < lines; i++) {
    char * ptr = getline_mem_alloc(file);
    no_more_newline(ptr);
    long int j = strlen(ptr);
    if (j > len) {
      len = j;
    }
    clear_char_ptr(ptr);
  }

  // clean up & return
  rewind(file);
  return(len + 1);
}

  if (string_is_valid(type, "memsave")) {
    // works when function run on file for maxstr
    maxstr = file_longest_string(file, len);
  } else if (string_is_valid(type, "nomemsave")) {
    // doesn't work with static buffer number...
    maxstr = MAX_BUFFER;
  } else {
    printf("specify memsave / nomemsave\n");
    exit(1);
  }

  char buffer[len][maxstr + 1];
  // initialize array. commented out because it changes the file
  // pointer to null. can't explain why. defintely a question
  // mark but this function in both modes passes valgrind cleanly
  // initialize array. commented out because it changes the file
  // pointer to null. can't explain why. defintely a question
  // mark but this function in both modes passes valgrind cleanly
  // now.
  /*for (int i = 0; i <= len; i++) {
    for (int j = 0; j <= maxstr; j++) {

file_reverse_output(FILE * file,
                         FILE * newfile,
                         char * type)

char a[10];

void main() {
    int i;
    char b;
    for (i=0; i<=10; i++) { b=a[i]; }
}

/tmp$ valgrind --tool=exp-sgcheck  ./a.out
==3182== exp-sgcheck, a stack and global array overrun detector
==3182== NOTE: This is an Experimental-Class Valgrind Tool
==3182== Copyright (C) 2003-2015, and GNU GPL'd, by OpenWorks Ltd et al.
==3182== Using Valgrind-3.11.0 and LibVEX; rerun with -h for copyright info
==3182== Command: ./a.out
==3182== 
==3182== Invalid read of size 1
==3182==    at 0x4004FF: main (a.c:6)
==3182==  Address 0x60103b expected vs actual:
==3182==  Expected: global array "a" of size 10 in object with soname "NONE"
==3182==  Actual:   unknown
==3182==  Actual:   is 0 after Expected
==3182== 
==3182== 
==3182== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)