/tmp/build/foma/foma-0.10.0+g279~a2d32b38/io.c

Bug Summary

File:	io.c
Warning:	line 601, column 5 Potential leak of memory pointed to by 'net_name'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name io.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/tmp/build/foma/foma-0.10.0+g279~a2d32b38 -resource-dir /usr/lib/llvm-16/lib/clang/16 -D _GNU_SOURCE -I /tmp/build/foma/foma-0.10.0+g279~a2d32b38 -internal-isystem /usr/lib/llvm-16/lib/clang/16/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wno-missing-field-initializers -Wno-deprecated -Wno-unused-parameter -std=c18 -fdebug-compilation-dir=/tmp/build/foma/foma-0.10.0+g279~a2d32b38 -ferror-limit 19 -fvisibility=hidden -fgnuc-version=4.2.1 -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/build/foma/scan-build/2024-09-11-155945-2678-1 -x c /tmp/build/foma/foma-0.10.0+g279~a2d32b38/io.c

1/*   Foma: a finite-state toolkit and library.                                 */
2/*   Copyright © 2008-2021 Mans Hulden                                         */

4/*   This file is part of foma.                                                */

6/*   Licensed under the Apache License, Version 2.0 (the "License");           */
7/*   you may not use this file except in compliance with the License.          */
8/*   You may obtain a copy of the License at                                   */

10/*      http://www.apache.org/licenses/LICENSE-2.0                             */

12/*   Unless required by applicable law or agreed to in writing, software       */
13/*   distributed under the License is distributed on an "AS IS" BASIS,         */
14/*   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  */
15/*   See the License for the specific language governing permissions and       */
16/*   limitations under the License.                                            */

18#include <stdio.h>
19#include <string.h>
20#include <stdlib.h>
21#include <stdarg.h>
22#include "foma.h"
23#include "zlib.h"

25#define TYPE_TRANSITION1 1
26#define TYPE_SYMBOL2 2
27#define TYPE_FINAL3 3
28#define TYPE_PROPERTY4 4
29#define TYPE_END5 5
30#define TYPE_ERROR6 6

32#define READ_BUF_SIZE4096 4096

34struct binaryline {
  int type;
  int state;
  int in;
  int target;
  int out;
  int symbol;
  char *name;
  char *value;
43};

45extern char *g_att_epsilon;

47struct io_buf_handle {
  char *io_buf;
  char *io_buf_ptr;
50};

52struct io_buf_handle *io_init();
53void io_free(struct io_buf_handle *iobh);
54static int io_gets(struct io_buf_handle *iobh, char *target);
55static size_t io_get_gz_file_size(char *filename);
56static size_t io_get_file_size(char *filename);
57static size_t io_get_regular_file_size(char *filename);
58size_t io_gz_file_to_mem (struct io_buf_handle *iobh, char *filename);
59int foma_net_print(struct fsm *net, gzFile outfile);
60struct fsm *io_net_read(struct io_buf_handle *iobh, char **net_name);
61static INLINEinline int explode_line (char *buf, int *values);


64void escape_print(FILE *stream, char* string) {
  int i;
  if (strchr(string, '"') != NULL((void*)0)) {
for (i = 0; *(string+i) != '\0'; i++) {
   if (*(string+i) == '"') {
fprintf(stream, "\\\"");
   } else {
fputc(*(string+i), stream);
   }
}
  } else {
fprintf(stream, "%s", string);
  }
77}

79int foma_write_prolog (struct fsm *net, char *filename) {
struct fsm_state *stateptr;
int i, *finals, *used_symbols, maxsigma;
FILE *out;
char *outstring, *instring, identifier[100];

if (filename == NULL((void*)0)) {
  out = stdoutstdout;
} else {
  if ((out = fopen(filename, "w")) == NULL((void*)0)) {
    printf("Error writing to file '%s'. Using stdout.\n", filename);
    out = stdoutstdout;
  }
  printf("Writing prolog to file '%s'.\n", filename);
}
fsm_count(net);
maxsigma = sigma_max(net->sigma);
used_symbols = calloc(maxsigma+1,sizeof(int));
finals = malloc(sizeof(int)*(net->statecount));
stateptr = net->states;
identifier[0] = '\0';

strcpy(identifier, net->name);

/* Print identifier */
fprintf(out, "%s%s%s", "network(",identifier,").\n");

for (i=0; (stateptr+i)->state_no != -1; i++) {
  if ((stateptr+i)->final_state == 1) {
    *(finals+((stateptr+i)->state_no)) = 1;
  } else {
    *(finals+((stateptr+i)->state_no)) = 0;
  }
  if ((stateptr+i)->in != -1) {
    *(used_symbols+((stateptr+i)->in)) = 1;
  }
  if ((stateptr+i)->out != -1) {
    *(used_symbols+((stateptr+i)->out)) = 1;
  }

}

for (i = 3; i <= maxsigma; i++) {
  if (*(used_symbols+i) == 0) {
    instring = sigma_string(i, net->sigma);
    if (strcmp(instring,"0") == 0) {
 instring = "%0";
    }
    fprintf(out, "symbol(%s, \"", identifier);
    escape_print(out, instring);
    fprintf(out, "\").\n");

  }
}

for (; stateptr->state_no != -1; stateptr++) {
  if (stateptr->target == -1)
    continue;
  fprintf(out, "arc(%s, %i, %i, ", identifier, stateptr->state_no, stateptr->target);
  if      (stateptr->in == 0) instring = "0";
  else if (stateptr->in == 1) instring = "?";
  else if (stateptr->in == 2) instring = "?";
  else instring = sigma_string(stateptr->in, net->sigma);
  if      (stateptr->out == 0) outstring = "0";
  else if (stateptr->out == 1) outstring = "?";
  else if (stateptr->out == 2) outstring = "?";
  else outstring = sigma_string(stateptr->out, net->sigma);

  if (strcmp(instring,"0") == 0 && stateptr->in != 0) instring = "%0";
  if (strcmp(outstring,"0") == 0 && stateptr->out != 0) outstring = "%0";
  if (strcmp(instring,"?") == 0 && stateptr->in > 2) instring = "%?";
  if (strcmp(outstring,"?") == 0 && stateptr->in > 2) outstring = "%?";
  /* Escape quotes */

  if (net->arity == 2 && stateptr->in == IDENTITY2 && stateptr->out == IDENTITY2) {
    fprintf(out, "\"?\").\n");
  }
  else if (net->arity == 2 && stateptr->in == stateptr->out && stateptr->in != UNKNOWN1) {
fprintf(out, "\"");
escape_print(out, instring);
fprintf(out, "\").\n");
  }
  else if (net->arity == 2) {
    fprintf(out, "\"");
    escape_print(out, instring);
    fprintf(out, "\":\"");
    escape_print(out, outstring);
    fprintf(out, "\").\n");
  }
  else if (net->arity == 1) {
fprintf(out, "\"");
escape_print(out, instring);
fprintf(out, "\").\n");
  }
}

for (i = 0; i < net->statecount; i++) {
  if (*(finals+i)) {
    fprintf(out, "final(%s, %i).\n", identifier, i);
  }
}
if (filename != NULL((void*)0)) {
    fclose(out);
}
free(finals);
free(used_symbols);
return 1;
186}

188struct fsm *read_att(char *filename) {

  struct fsm_construct_handle *h;
  struct fsm *net;
  int i;
  char inword[1024], delimiters[] = "\t", *tokens[6];
  FILE *INFILE;

  INFILE = fopen(filename, "r");
  if (INFILE == NULL((void*)0)) {
      return(NULL((void*)0));
  }

  h = fsm_construct_init(filename);
  while (fgets(inword, 1024, INFILE) != NULL((void*)0)) {
      if (inword[strlen(inword)-1] == '\n') {
          inword[strlen(inword)-1] = '\0';
      }
      tokens[0] = strtok(inword, delimiters);
      i = 0;
      if (tokens[0] != NULL((void*)0)) {
          i = 1;
          for ( ; ; ) {
              tokens[i] = strtok(NULL((void*)0), delimiters);
              if (tokens[i] == NULL((void*)0)) {
                  break;
              }
              i++;
              if (i == 6)
                  break;
          }
      }
      if (i == 0) { continue; }
      if (i >= 4) {
          if (strcmp(tokens[2],g_att_epsilon) == 0)
              tokens[2] = "@_EPSILON_SYMBOL_@";
          if (strcmp(tokens[3],g_att_epsilon) == 0)
              tokens[3] = "@_EPSILON_SYMBOL_@";

          fsm_construct_add_arc(h, atoi(tokens[0]), atoi(tokens[1]), tokens[2], tokens[3]);
      }
      else if (i <= 3 && i > 0) {
          fsm_construct_set_final(h,atoi(tokens[0]));
      }
  }
  fsm_construct_set_initial(h,0);
  fclose(INFILE);
  net = fsm_construct_done(h);
  fsm_count(net);
  net = fsm_topsort(net);
  return(net);
239}

241struct fsm *fsm_read_prolog (char *filename) {
  char buf [1024], temp [1024], in [128], out[128], *temp_ptr, *temp_ptr2;
  int arity, source, target, has_net;
  struct fsm *outnet;
  struct fsm_construct_handle *outh = NULL((void*)0);
  FILE *prolog_file;

  has_net = 0;
  prolog_file = fopen(filename, "r");
  if (prolog_file == NULL((void*)0)) {
return NULL((void*)0);
  }

  while (fgets(buf, 1023, prolog_file) != NULL((void*)0)) {
if (strstr(buf, "network(") == buf) {
   /* Extract network name */
   if (has_net == 1) {
perror("WARNING: prolog file contains multiple nets. Only returning the first one.\n");
break;
   } else {
has_net = 1;
   }
   temp_ptr = strstr(buf, "network(")+8;
   temp_ptr2 = strstr(buf, ").");
   strncpy(temp, temp_ptr, (temp_ptr2 - temp_ptr));
   temp[(temp_ptr2-temp_ptr)] = '\0';

   /* Start network */
   outh = fsm_construct_init(temp);
}
if (strstr(buf, "final(") == buf) {
   temp_ptr = strstr(buf, " ");
   temp_ptr++;
   temp_ptr2 = strstr(temp_ptr, ").");
   strncpy(temp, temp_ptr, (temp_ptr2 - temp_ptr));
   temp[(temp_ptr2-temp_ptr)] = '\0';

   fsm_construct_set_final(outh, atoi(temp));
}
if (strstr(buf, "symbol(") == buf) {
   temp_ptr = strstr(buf, ", \"")+3;
   temp_ptr2 = strstr(temp_ptr, "\").");
   strncpy(temp, temp_ptr, (temp_ptr2 - temp_ptr));
   temp[(temp_ptr2-temp_ptr)] = '\0';
   if (strcmp(temp, "%0") == 0)
strcpy(temp, "0");
   //printf("special: %s\n",temp);

   if (fsm_construct_check_symbol(outh, temp) == -1) {
fsm_construct_add_symbol(outh, temp);
   }
   continue;
}
if (strstr(buf, "arc(") == buf) {
   in[0] = '\0';
   out[0] = '\0';

   if (strstr(buf, "\":\"") == NULL((void*)0) || strstr(buf, ", \":\").") != NULL((void*)0)) {
arity = 1;
   } else {
arity = 2;
   }

   /* Get source */
   temp_ptr = strstr(buf, " ");
   temp_ptr++;
   temp_ptr2 = strstr(temp_ptr, ",");
   strncpy(temp, temp_ptr, (temp_ptr2 - temp_ptr));
   temp[(temp_ptr2-temp_ptr)] = '\0';
   source = atoi(temp);

   /* Get target */
   temp_ptr = strstr(temp_ptr2, " ");
   temp_ptr++;
   temp_ptr2 = strstr(temp_ptr, ",");
   strncpy(temp, temp_ptr, (temp_ptr2 - temp_ptr));
   temp[(temp_ptr2-temp_ptr)] = '\0';
   target = atoi(temp);

   temp_ptr = strstr(temp_ptr2, "\"");
   temp_ptr++;
   if (arity == 2)  {
temp_ptr2 = strstr(temp_ptr, "\":");
   } else {
temp_ptr2 = strstr(temp_ptr, "\").");
   }
   strncpy(in, temp_ptr, (temp_ptr2 - temp_ptr));
   in[(temp_ptr2 - temp_ptr)] = '\0';

   if (arity == 2) {
temp_ptr = strstr(temp_ptr2, ":\"");
temp_ptr += 2;
temp_ptr2 = strstr(temp_ptr, "\").");
strncpy(out, temp_ptr, (temp_ptr2 - temp_ptr));
out[(temp_ptr2 - temp_ptr)] = '\0';
   }
   if (arity == 1 && (strcmp(in, "?") == 0)) {
strcpy(in,"@_IDENTITY_SYMBOL_@");
   }
   if (arity == 2 && (strcmp(in, "?") == 0)) {
strcpy(in,"@_UNKNOWN_SYMBOL_@");
   }
   if (arity == 2 && (strcmp(out, "?") == 0)) {
strcpy(out,"@_UNKNOWN_SYMBOL_@");
   }
   if (strcmp(in, "0") == 0) {
strcpy(in,"@_EPSILON_SYMBOL_@");
   }
   if (strcmp(out, "0") == 0) {
strcpy(out,"@_EPSILON_SYMBOL_@");
   }
   if (strcmp(in, "%0") == 0) {
strcpy(in,"0");
   }
   if (strcmp(out, "%0") == 0) {
strcpy(out,"0");
   }
   if (strcmp(in, "%?") == 0) {
strcpy(in,"?");
   }
   if (strcmp(out, "%?") == 0) {
strcpy(out,"?");
   }

   if (arity == 1) {
fsm_construct_add_arc(outh, source, target, in, in);
   } else {
fsm_construct_add_arc(outh, source, target, in, out);
   }
}
  }
  fclose(prolog_file);
  if (has_net == 1) {
fsm_construct_set_initial(outh, 0);
outnet = fsm_construct_done(outh);
fsm_topsort(outnet);
return(outnet);
  } else {
return(NULL((void*)0));
  }
381}

383struct io_buf_handle *io_init() {
  struct io_buf_handle *iobh;
  iobh = malloc(sizeof(struct io_buf_handle));
  (iobh->io_buf) = NULL((void*)0);
  (iobh->io_buf_ptr) = NULL((void*)0);
  return(iobh);
389}

391void io_free(struct io_buf_handle *iobh) {
  if (iobh->io_buf != NULL((void*)0)) {
      free(iobh->io_buf);
      (iobh->io_buf) = NULL((void*)0);
  }
  free(iobh);
397}

399char *spacedtext_get_next_line(char **text) {
  char *t, *ret;
  ret = *text;
  if (**text == '\0')
return NULL((void*)0);
  for (t = *text; *t != '\0' && *t != '\n'; t++) {
  }
  if (*t == '\0')
*text = t;
  else
*text = t+1;
  *t = '\0';
  return(ret);
412}

414char *spacedtext_get_next_token(char **text) {
  char *t, *ret;
  if (**text == '\0' || **text == '\n')
return NULL((void*)0);
  for ( ; **text == ' ' ; (*text)++) {
  }
  ret = *text;
  for (t = *text; *t != '\0' && *t != '\n' && *t != ' '; t++) {
  }
  if (*t == '\0' || *t == '\n')
*text = t;
  else
*text = t+1;
  *t = '\0';
  return(ret);
429}

431struct fsm *fsm_read_spaced_text_file(char *filename) {
  struct fsm_trie_handle *th;
  char *text, *textorig, *insym, *outsym, *t1, *t2, *l1, *l2;

  text = textorig = file_to_mem(filename);

  if (text == NULL((void*)0))
return NULL((void*)0);
  th = fsm_trie_init();
  for (;;) {
for ( ; *text != '\0' && *text == '\n'; text++) { }
t1 = spacedtext_get_next_line(&text);
if (t1 == NULL((void*)0))
   break;
if (strlen(t1) == 0)
   continue;
t2 = spacedtext_get_next_line(&text);
if (t2 == NULL((void*)0) || strlen(t2) == 0) {
   for (l1 = t1; (insym = spacedtext_get_next_token(&l1)) != NULL((void*)0); ) {
if (strcmp(insym, "0") == 0)
    fsm_trie_symbol(th,  "@_EPSILON_SYMBOL_@", "@_EPSILON_SYMBOL_@");
else if (strcmp(insym, "%0") == 0)
    fsm_trie_symbol(th,  "0", "0");
else
    fsm_trie_symbol(th,  insym, insym);
   }
   fsm_trie_end_word(th);
} else {
   for (l1 = t1, l2 = t2; ; ) {
insym = spacedtext_get_next_token(&l1);
outsym = spacedtext_get_next_token(&l2);
if (insym == NULL((void*)0) && outsym == NULL((void*)0))
    break;
if (insym == NULL((void*)0) || strcmp(insym, "0") == 0)
    insym = "@_EPSILON_SYMBOL_@";
if (strcmp(insym, "%0") == 0)
    insym = "0";
if (outsym == NULL((void*)0) || strcmp(outsym, "0") == 0)
    outsym = "@_EPSILON_SYMBOL_@";
if (strcmp(outsym, "%0") == 0)
    outsym = "0";
fsm_trie_symbol(th, insym, outsym);
   }
   fsm_trie_end_word(th);
}
  }
  free(textorig);
  return(fsm_trie_done(th));
479}

481struct fsm *fsm_read_text_file(char *filename) {
  struct fsm_trie_handle *th;
  char *text, *textp1, *textp2;
  int lastword;

  text = file_to_mem(filename);
  if (text == NULL((void*)0)) {
return NULL((void*)0);
  }
  textp1 = text;
  th = fsm_trie_init();

  for (lastword = 0 ; lastword == 0 ; textp1 = textp2+1) {
for (textp2 = textp1 ; *textp2 != '\n' && *textp2 != '\0'; textp2++) {
}
if (*textp2 == '\0') {
   lastword = 1;
   if (textp2 == textp1)
break;
}
*textp2 = '\0';
if (strlen(textp1) > 0)
   fsm_trie_add_word(th, textp1);
  }
  free(text);
  return(fsm_trie_done(th));
507}

509int fsm_write_binary_file(struct fsm *net, char *filename) {
  gzFile outfile;
  if ((outfile = gzopen(filename,"wb")) == NULL((void*)0)) {
return(1);
  }
  foma_net_print(net, outfile);
  gzclose(outfile);
  return(0);
517}

519struct fsm *fsm_read_binary_file_multiple(fsm_read_binary_handle fsrh) {
  char *net_name;
  struct fsm *net;
  struct io_buf_handle *iobh;
  iobh = (struct io_buf_handle *) fsrh;
  net = io_net_read(iobh, &net_name);
  if (net == NULL((void*)0)) {
io_free(iobh);
return(NULL((void*)0));
  } else {
free(net_name);
return(net);
  }
532}

534fsm_read_binary_handle fsm_read_binary_file_multiple_init(char *filename) {

  struct io_buf_handle *iobh;
  fsm_read_binary_handle fsm_read_handle;

  iobh = io_init();
  if (io_gz_file_to_mem(iobh, filename) == 0) {
io_free(iobh);
return NULL((void*)0);
  }
  fsm_read_handle = (void *) iobh;
  return(fsm_read_handle);
546}

548struct fsm *fsm_read_binary_file(char *filename) {
  char *net_name;
  struct fsm *net;
  struct io_buf_handle *iobh;
  iobh = io_init();
  if (io_gz_file_to_mem(iobh, filename) == 0) {
io_free(iobh);
      return NULL((void*)0);
  }
  net = io_net_read(iobh, &net_name);
  io_free(iobh);
  return(net);
560}

562int save_defined(struct defined_networks *def, char *filename) {
  struct defined_networks *d;
  gzFile outfile;
  if (def == NULL((void*)0)) {
      fprintf(stderrstderr, "No defined networks.\n");
      return(0);
  }
  if ((outfile = gzopen(filename, "wb")) == NULL((void*)0)) {
      printf("Error opening file %s for writing.\n", filename);
      return(-1);
  }
  printf("Writing definitions to file %s.\n", filename);
  for (d = def; d != NULL((void*)0); d = d->next) {
      if (!d->net) {
          printf("Skipping definition without network.\n");
          continue;
      }
      strncpy(d->net->name, d->name, FSM_NAME_LEN40);
      foma_net_print(d->net, outfile);
  }
  gzclose(outfile);
  return(1);
584}

586int load_defined(struct defined_networks *def, char *filename) {
  struct fsm *net;
  char *net_name;
  struct io_buf_handle *iobh;

  iobh = io_init();
  printf("Loading definitions from %s.\n",filename);
  if (io_gz_file_to_mem(iobh, filename) == 0) {
1
Taking false branch→
      fprintf(stderrstderr, "File error.\n");
io_free(iobh);
      return 0;
  }
  while ((net = io_net_read(iobh, &net_name)) != NULL((void*)0)) {
2
←
Calling 'io_net_read'→
14
←
Returned allocated memory via 2nd parameter→
15
←
Loop condition is false. Execution continues on line 601→
      add_defined(def, net, net_name);
  }
  io_free(iobh);
16
←
Potential leak of memory pointed to by 'net_name'
  return(1);
603}

605static INLINEinline int explode_line(char *buf, int *values) {
  int i, j, items;
  j = i = items = 0;
  for (;;) {
      for (i = j; *(buf+j) != ' ' && *(buf+j) != '\0'; j++) { }
      if (*(buf+j) == '\0') {
          *(values+items) = atoi(buf+i);
          items++;
          break;
      } else{
          *(buf+j) = '\0';
          *(values+items) = atoi(buf+i);
          items++;
          j++;
      }
  }
  return(items);
622}

624/* The file format we use is an extremely simple text format */
625/* which is gzip compressed through libz and consists of the following sections: */

627/* ##foma-net VERSION##*/
628/* ##props## */
629/* PROPERTIES LINE */
630/* ##sigma## */
631/* ...SIGMA LINES... */
632/* ##states## */
633/* ...TRANSITION LINES... */
634/* ##end## */

636/* Several networks may be concatenated in one file */

638/* The initial identifier is "##foma-net 1.0##" */
639/* where 1.0 is the version number for the file format */
640/* followed by the line "##props##" */
641/* which is followed by a line of space separated integers */
642/* which correpond to: */

644/* arity arccount statecount linecount finalcount pathcount is_deterministic */
645/* is_pruned is_minimized is_epsilon_free is_loop_free is_completed name  */

647/* where name is used if defined networks are saved/loaded */

649/* Following the props line, we accept anything (for future expansion) */
650/* until we find ##sigma## */

652/* the section beginning with "##sigma##" consists of lines with two fields: */
653/* number string */
654/* correponding to the symbol number and the symbol string */

656/* the section beginning with "##states##" consists of lines of ASCII integers */
657/* with 2-5 fields to avoid some redundancy in every line corresponding to a */
658/* transition where otherwise state numbers would be unnecessarily repeated and */
659/* out symbols also (if in = out as is the case for recognizers/simple automata) */

661/* The information depending on the number of fields in the lines is as follows: */

663/* 2: in target (here state_no is the same as the last mentioned one and out = in) */
664/* 3: in out target (again, state_no is the same as the last mentioned one) */
665/* 4: state_no in target final_state (where out = in) */
666/* 5: state_no in out target final_state */

668/* There is no harm in always using 5 fields; however this will take up more space */

670/* As in struct fsm_state, states without transitions are represented as a 4-field: */
671/* state_no -1 -1 final_state (since in=out for 4-field lines, out = -1 as well) */

673/* AS gzopen will read uncompressed files as well, one can gunzip a file */
674/* that contains a network and still read it */

676struct fsm *io_net_read(struct io_buf_handle *iobh, char **net_name) {

  char buf[READ_BUF_SIZE4096];
  struct fsm *net;
  struct fsm_state *fsm;

  char *new_symbol;
  int i, items, new_symbol_number, laststate, lineint[5], *cm;
  int extras;
  char last_final = '1';

  if (io_gets(iobh, buf) == 0) {
3
←
Assuming the condition is false→
4
←
Taking false branch→
      return NULL((void*)0);
  }

  net = fsm_create("");

  if (strcmp(buf, "##foma-net 1.0##") != 0) {
5
←
Assuming the condition is false→
6
←
Taking false branch→
fsm_destroy(net);
      perror("File format error foma!\n");
      return NULL((void*)0);
  }
  io_gets(iobh, buf);
  if (strcmp(buf, "##props##") != 0) {
7
←
Assuming the condition is false→
8
←
Taking false branch→
      perror("File format error props!\n");
fsm_destroy(net);
      return NULL((void*)0);
  }
  /* Properties */
  io_gets(iobh, buf);
  extras = 0;
  sscanf(buf, "%i %i %i %i %i %lld %i %i %i %i %i %i %s", &net->arity, &net->arccount, &net->statecount, &net->linecount, &net->finalcount, &net->pathcount, &net->is_deterministic, &net->is_pruned, &net->is_minimized, &net->is_epsilon_free, &net->is_loop_free, &extras, buf);
  strncpy(net->name, buf, FSM_NAME_LEN40);
  *net_name = strdup(buf);
9
←
Memory is allocated→
  io_gets(iobh, buf);

  net->is_completed = (extras & 3);
  net->arcs_sorted_in = (extras & 12) >> 2;
  net->arcs_sorted_out = (extras & 48) >> 4;

  /* Sigma */
  while (strcmp(buf, "##sigma##") != 0) { /* Loop until we encounter ##sigma## */
10
←
Assuming the condition is true→
11
←
Loop condition is true.  Entering loop body→
      if (buf[0] == '\0') {
12
←
Assuming the condition is true→
13
←
Taking true branch→
 printf("File format error at sigma definition!\n");
 fsm_destroy(net);
 return NULL((void*)0);
      }
      io_gets(iobh, buf);
  }

  for (;;) {
      io_gets(iobh, buf);
      if (buf[0] == '#') break;
      if (buf[0] == '\0') continue;
      new_symbol = strstr(buf, " ");
new_symbol[0] = '\0';
new_symbol++;
if (new_symbol[0] == '\0') {
   sscanf(buf,"%i", &new_symbol_number);
   sigma_add_number(net->sigma, "\n", new_symbol_number);
} else {
   sscanf(buf,"%i", &new_symbol_number);
   sigma_add_number(net->sigma, new_symbol, new_symbol_number);
}
  }

  /* States */
  if (strcmp(buf, "##states##") != 0) {
      printf("File format error!\n");
      return NULL((void*)0);
  }
  net->states = malloc(net->linecount*sizeof(struct fsm_state));
  fsm = net->states;
  laststate = -1;
  for (i=0; ;i++) {
      io_gets(iobh, buf);
      if (buf[0] == '#') break;

      /* scanf is just too slow here */

      //items = sscanf(buf, "%i %i %i %i %i",&lineint[0], &lineint[1], &lineint[2], &lineint[3], &lineint[4]);

      items = explode_line(buf, &lineint[0]);

      switch (items) {
      case 2:
          (fsm+i)->state_no = laststate;
          (fsm+i)->in = lineint[0];
          (fsm+i)->out = lineint[0];
          (fsm+i)->target = lineint[1];
          (fsm+i)->final_state = last_final;
          break;
      case 3:
          (fsm+i)->state_no = laststate;
          (fsm+i)->in = lineint[0];
          (fsm+i)->out = lineint[1];
          (fsm+i)->target = lineint[2];
          (fsm+i)->final_state = last_final;
          break;
      case 4:
          (fsm+i)->state_no = lineint[0];
          (fsm+i)->in = lineint[1];
          (fsm+i)->out = lineint[1];
          (fsm+i)->target = lineint[2];
          (fsm+i)->final_state = lineint[3];
          laststate = lineint[0];
          last_final = lineint[3];
          break;
      case 5:
          (fsm+i)->state_no = lineint[0];
          (fsm+i)->in = lineint[1];
          (fsm+i)->out = lineint[2];
          (fsm+i)->target = lineint[3];
          (fsm+i)->final_state = lineint[4];
          laststate = lineint[0];
          last_final = lineint[4];
          break;
      default:
          printf("File format error\n");
          return NULL((void*)0);
      }
      if (laststate > 0) {
          (fsm+i)->start_state = 0;
      } else if (laststate == -1) {
          (fsm+i)->start_state = -1;
      } else {
          (fsm+i)->start_state = 1;
      }

  }
  if (strcmp(buf, "##cmatrix##") == 0) {
      cmatrix_init(net);
      cm = net->medlookup->confusion_matrix;
      for (;;) {
          io_gets(iobh, buf);
          if (buf[0] == '#') break;
          sscanf(buf,"%i", &i);
          *cm = i;
          cm++;
      }
  }
  if (strcmp(buf, "##end##") != 0) {
      printf("File format error!\n");
      return NULL((void*)0);
  }
  return(net);
822}

824static int io_gets(struct io_buf_handle *iobh, char *target) {
  int i;
  for (i = 0; *((iobh->io_buf_ptr)+i) != '\n' && *((iobh->io_buf_ptr)+i) != '\0'; i++) {
      *(target+i) = *((iobh->io_buf_ptr)+i);
  }
  *(target+i) = '\0';
  if (*((iobh->io_buf_ptr)+i) == '\0')
  (iobh->io_buf_ptr) = (iobh->io_buf_ptr) + i;
  else
      (iobh->io_buf_ptr) = (iobh->io_buf_ptr) + i + 1;

  return(i);
836}

838int foma_net_print(struct fsm *net, gzFile outfile) {
  struct sigma *sigma;
  struct fsm_state *fsm;
  int i, maxsigma, laststate, *cm, extras;

  /* Header */
  gzprintf(outfile, "%s","##foma-net 1.0##\n");

  /* Properties */
  gzprintf(outfile, "%s","##props##\n");

  extras = (net->is_completed) | (net->arcs_sorted_in << 2) | (net->arcs_sorted_out << 4);

  gzprintf(outfile,
    "%i %i %i %i %i %lld %i %i %i %i %i %i %s\n", net->arity, net->arccount, net->statecount, net->linecount, net->finalcount, net->pathcount, net->is_deterministic, net->is_pruned, net->is_minimized, net->is_epsilon_free, net->is_loop_free, extras, net->name);

  /* Sigma */
  gzprintf(outfile, "%s","##sigma##\n");
  for (sigma = net->sigma; sigma != NULL((void*)0) && sigma->number != -1; sigma = sigma->next) {
      gzprintf(outfile, "%i %s\n",sigma->number, sigma->symbol);
  }

  /* State array */
  laststate = -1;
  gzprintf(outfile, "%s","##states##\n");
  for (fsm = net->states; fsm->state_no !=-1; fsm++) {
      if (fsm->state_no != laststate) {
          if (fsm->in != fsm->out) {
              gzprintf(outfile, "%i %i %i %i %i\n",fsm->state_no, fsm->in, fsm->out, fsm->target, fsm->final_state);
          } else {
              gzprintf(outfile, "%i %i %i %i\n",fsm->state_no, fsm->in, fsm->target, fsm->final_state);
          }
      } else {
          if (fsm->in != fsm->out) {
              gzprintf(outfile, "%i %i %i\n", fsm->in, fsm->out, fsm->target);
          } else {
              gzprintf(outfile, "%i %i\n", fsm->in, fsm->target);
          }
      }
      laststate = fsm->state_no;
  }
  /* Sentinel for states */
  gzprintf(outfile, "-1 -1 -1 -1 -1\n");

  /* Store confusion matrix */
  if (net->medlookup != NULL((void*)0) && net->medlookup->confusion_matrix != NULL((void*)0)) {

      gzprintf(outfile, "%s","##cmatrix##\n");
      cm = net->medlookup->confusion_matrix;
      maxsigma = sigma_max(net->sigma)+1;
      for (i=0; i < maxsigma*maxsigma; i++) {
          gzprintf(outfile, "%i\n", *(cm+i));
      }
  }

  /* End */
  gzprintf(outfile, "%s","##end##\n");
  return(1);
896}

898int net_print_att(struct fsm *net, FILE *outfile) {
  struct fsm_state *fsm;
  struct fsm_sigma_list *sl;
  int i, prev;

  fsm = net->states;
  sl = sigma_to_list(net->sigma);
  if (sigma_max(net->sigma) >= 0) {
      (sl+0)->symbol = g_att_epsilon;
  }
  for (i=0; (fsm+i)->state_no != -1; i++) {
      if ((fsm+i)->target != -1) {
          fprintf(outfile, "%i\t%i\t%s\t%s\n",(fsm+i)->state_no,(fsm+i)->target, (sl+(fsm+i)->in)->symbol, (sl+(fsm+i)->out)->symbol);
      }
  }
  prev = -1;
  for (i=0; (fsm+i)->state_no != -1; prev = (fsm+i)->state_no, i++) {
      if ((fsm+i)->state_no != prev && (fsm+i)->final_state == 1) {
          fprintf(outfile, "%i\n",(fsm+i)->state_no);
      }
  }
  free(sl);
  return(1);
921}

923static size_t io_get_gz_file_size(char *filename) {

  FILE    *infile;
  size_t    numbytes;
  unsigned char bytes[4];
  unsigned int ints[4], i;

  /* The last four bytes in a .gz file shows the size of the uncompressed data */
  infile = fopen(filename, "r");
  fseek(infile, -4, SEEK_END2);
  fread(&bytes, 1, 4, infile);
  fclose(infile);
  for (i = 0 ; i < 4 ; i++) {
      ints[i] = bytes[i];
  }
  numbytes = ints[0] | (ints[1] << 8) | (ints[2] << 16 ) | (ints[3] << 24);
  return(numbytes);
940}

942static size_t io_get_regular_file_size(char *filename) {

  FILE    *infile;
  size_t    numbytes;

  infile = fopen(filename, "r");
  fseek(infile, 0L, SEEK_END2);
  numbytes = ftell(infile);
  fclose(infile);
  return(numbytes);
952}


955static size_t io_get_file_size(char *filename) {
  gzFile FILE;
  size_t size;
  FILE = gzopen(filename, "r");
  if (FILE == NULL((void*)0)) {
      return(0);
  }
  if (gzdirect(FILE) == 1) {
      gzclose(FILE);
      size = io_get_regular_file_size(filename);
  } else {
      gzclose(FILE);
      size = io_get_gz_file_size(filename);
  }
  return(size);
970}

972size_t io_gz_file_to_mem(struct io_buf_handle *iobh, char *filename) {

  size_t size;
  gzFile FILE;

  size = io_get_file_size(filename);
  if (size == 0) {
      return 0;
  }
  (iobh->io_buf) = malloc((size+1)*sizeof(char));
  FILE = gzopen(filename, "rb");
  gzread(FILE, iobh->io_buf, size);
  gzclose(FILE);
  *((iobh->io_buf)+size) = '\0';
  iobh->io_buf_ptr = iobh->io_buf;
  return(size);
988}

990typedef struct BOM {
  char code[4];
  int len;
  char* name;
994} BOM;

996static BOM BOM_codes[] = {
  { { 0xEF, 0xBB, 0xBF }, 3, "UTF-8"},
  { { 0xFF, 0xFE, 0x00, 0x00 }, 4, "UTF-32LE" },
  { { 0x00, 0x00, 0xFE, 0xFF }, 4, "UTF-32BE" },
  { { 0xFF, 0xFE }, 2, "UTF16-LE" },
  { { 0xFE, 0xFF }, 2, "UTF16-BE" },
  { { 0, } , 0, NULL((void*)0) },
1003};

1005BOM *check_BOM(char *buffer) {
  BOM *bom;
  for(bom = BOM_codes; bom->len; bom++) {
      if(strncmp(bom->code, buffer, bom->len) == 0) {
          return bom;
      }
  }
  return NULL((void*)0);
1013}

1015char *file_to_mem(char *name) {
  FILE    *infile;
  size_t    numbytes;
  char *buffer;
  BOM  *bom;
  infile = fopen(name, "r");
  if(infile == NULL((void*)0)) {
      printf("Error opening file '%s'\n",name);
      return NULL((void*)0);
  }
  fseek(infile, 0L, SEEK_END2);
  numbytes = ftell(infile);
  fseek(infile, 0L, SEEK_SET0);
  buffer = (char*)malloc((numbytes+1) * sizeof(char));
  if(buffer == NULL((void*)0)) {
      printf("Error reading file '%s'\n",name);
      return NULL((void*)0);
  }
  if (fread(buffer, sizeof(char), numbytes, infile) != numbytes) {
      printf("Error reading file '%s'\n",name);
      return NULL((void*)0);
  }

  bom = check_BOM(buffer);
  if (bom != NULL((void*)0)) {
      printf("%s BOM mark is detected in file '%s'.\n",bom->name,name);
      return NULL((void*)0);
  }
  fclose(infile);
  *(buffer+numbytes)='\0';
  return(buffer);
1046}