/*
    genstubdll - Generate stub-library acting like an import-library
		 using .def file syntax.
    Copyright (C) 2014  mingw-w64 project

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

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

#include "token.h"

static void addCh (int);
static void delCh (void);
static void zeroCh (void);
static int pCh (void);
static int rCh (void);
static void bCh (int);

typedef struct sMem {
  struct sMem *next;
  size_t len;
  char name[1];
} sMem;

static int t_max = 0, t_pos = 0;
static char *t_buf = NULL;
static int t_backch = -1;
static FILE *t_in = NULL;
static int exports_seen = 0;

static sMem *t_smem = NULL;
sSymbol *t_sym = NULL;
static sSymbol *t_lastsym = NULL;

const char *
unifyCat (const char *s, const char *t)
{
  char *h;
  const char *r;

  if (!t || *t == 0) return unifyStr (s);
  if (!s || *s == 0) return unifyStr (t);
  h = (char *) malloc (strlen (s) + strlen (t) + 1);
  strcpy (h, s); strcat (h, t);
  r = unifyStr (h);
  free (h);

  return r;
}

const char *
unifyStr (const char *s)
{
  sMem *p,*c,*n;
  size_t l;

  if (*s == 0)
    return "";

  l = strlen (s);
  p = NULL; c = t_smem;

  while (c != NULL && c->len < l)
    c = (p = c)->next;

  while (c != NULL && c->len == l)
    {
      int e = memcmp (c->name, s, l);
      if (!e) return c->name;
      if (e > 0) break;
      c = (p = c)->next;
    }

  n = (sMem *) malloc (sizeof (sMem) + l);
  n->next = c;
  if (!p)
    t_smem = n;
  else
    p->next = n;
  n->len = l;
  strcpy (n->name, s);

  return n->name;
}
    
static void addCh (int ch)
{
  if ((t_pos + 2) >= t_max)
    {
      char *h = malloc (t_max + 128);
      if (!h)
	{
	  fprintf (stderr, "Fatal error: Run out of memory\n");
	  exit (2);
	}
      h[t_pos] = 0;

      if (t_pos)
	memcpy (h, t_buf, t_pos);
      if (t_buf)
	free (t_buf);
      t_buf = h;
      t_max += 128;
    }

  if (ch < 0)
    return;

  t_buf[t_pos++] = (char) ch;
  t_buf[t_pos] = 0;
}

static void delCh (void)
{
  if (t_pos > 0)
    {
      t_buf[--t_pos] = 0;
    }
  else if (!t_buf)
    addCh (-1);
}

static void zeroCh (void)
{
  if (t_pos) { t_buf[0] = 0; t_pos = 0; }
  else if (!t_buf) addCh (-1);
}

static int pCh (void)
{
  int r = t_backch;

  if (r != -1)
    return r;

  r = rCh ();
  bCh (r);
  return r;
}

static int rCh (void)
{
  int r = t_backch;
  unsigned char ch;

  if (r != -1) { t_backch = -1; }
  else {
    if (feof (t_in) || fread (&ch, 1, 1, t_in) != 1)
      return r;
    r = (int) ch;  r &= 0xff;
  }

  if (r == '\r')
    return rCh ();

  addCh (r);
  return r;
}

static void bCh (int ch)
{
  if (ch < 0) return;
  delCh ();
  t_backch = ch;
}

static void readDigit (void)
{
  int r;
  r = rCh ();
  if (r == '0') {
    switch (pCh ()) {
    case 'x': case 'X': case 'o': case 'O': rCh (); break;
    default: break;
    }
  }
  while ((r = pCh ()) != -1 && ((r >= '0' && r <= '9')
	 || (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z')))
    rCh ();
}

static int lexit (void)
{
  int r;

redo:
  do {
    zeroCh ();
    if ((r = rCh ()) == -1) return -1;
  } while (r <= 0x20 && r != '\n');

  /* Ignore comment.  Either introduced by semicolon, or by hash sign.  */
  if (r == ';' || r == '#') {
    while (1) {
      if ((r = pCh ()) == -1) return 0;
      if (r == '\n') break;
      rCh ();
    }
    goto redo;
  }
  switch (r) {
  case '=': if (pCh () == r) { rCh(); return TK_EQUALEQUAL; }
   return r;
  case '@': case ',': case '.': case '\n': return r;
  case '"':
    zeroCh ();
    while ((r = pCh ()) != -1 && r != '"')
      {
	rCh ();
	if (r == '\\') {
	  if (rCh () == -1) { delCh (); r = -1; break; }
	}
      }
    if (r == '"')
      { rCh (); delCh (); }
    return TK_STRING;
  case '0': case '1': case '2': case '3': case '4':
  case '5': case '6': case '7': case '8': case '9':
    bCh (r); readDigit (); return TK_DIGIT;
  default:
    if (r == '_' || r == '?' || (r >= 'a' && r <= 'z')
	|| (r >= 'A' && r <= 'Z'));
    else return TK_UNKNOWN;
    while ((r = pCh ()) != -1) {
      if (r <= 0x20) break;
      rCh ();
    }
    if (exports_seen == 0)
      {
	if (!strcmp (t_buf, "LIBRARY")) return TK_LIBRARY;
	if (!strcmp (t_buf, "EXPORTS")) return TK_EXPORTS;
      }
    else
      {
	if (!strcmp (t_buf, "DATA")) return TK_DATA;
      }
    return TK_NAME;
  }
}

static int lexit2 (void)
{
  static int last = '\n';
  int r;
  if (last == -1)
    return -1;
redo:
  r = lexit ();

  /* Eat double new-lines.  */
  if (r == '\n' && last == r)
    goto redo;
  if (r == TK_EXPORTS || r == TK_LIBRARY)
  {
    if (last != TK_NL)
      r = TK_NAME;
  } else if (r == TK_DATA && last == TK_NL)
    r = TK_NAME;

  if (r == TK_EXPORTS)
    exports_seen = 1;
  if (r == TK_UNKNOWN)
    {
      fprintf (stderr, "Unexpected character ,%s'\n", t_buf);
      goto redo;
    }
  last = r;
  return r;
}

const char *cur_libname = "";
static const char *cur_symbol = "";
static const char *cur_libsymbol = "";
static const char *cur_alias = "";
static int cur_data = 0;

static int
expect_newline (const char *stmt)
{
  int r;
  int first = 1;

  while ((r = lexit2 ()) != -1 && r != TK_NL)
    {
      if (first == 1)
	fprintf (stderr, "Unexpected token in %s statment: ,%s", stmt, t_buf);
      else
        fprintf (stderr, " %s", t_buf);
      first = 0;
    }
  if (!first)
    fprintf (stderr, "'.\n");
  return r;
}

static int parseit (void)
{
  int r;

  if (!exports_seen) {
    if ((r = lexit2 ()) == -1)
      return 0;
    if (r == TK_EXPORTS)
    {
      r = expect_newline ("EXPORTS");
      return (r != -1 ? 1 : 0);
    }
    if (r == TK_LIBRARY)
    {
      r = lexit2 ();
      if (r != TK_STRING && r != TK_NAME)
	{
	  fprintf (stderr, "Expect name/string after LIBRARY keyword.\n");
	  return (r != -1 ? 1 : 0);
	}

      cur_libname = unifyStr (t_buf);

      fprintf (stderr, "Current library-name set to ,%s'\n", cur_libname);

      r = expect_newline ("LIBRARY");
      return (r != -1 ? 1 : 0);
    }
  } else {
    if ((r = lexit2 ()) == -1) return 0;
    if (r != TK_NAME)
    {
      fprintf (stderr, "Unexpected token ,%s'.  Would have expected a string/name.\n", t_buf);
      return (expect_newline ("UNKNOWN") == -1 ? 0 : 1);
    }
    cur_symbol = unifyStr (t_buf);
    cur_alias = "";
    cur_libsymbol = "";
    cur_data = 0;
    while ((r = lexit2 ()) != -1 && r != TK_NL)
    {
      if (r == TK_DATA)
	cur_data = 1;
      else if (r == TK_EQUAL)
	{
	  r = lexit2 ();
	  if (r != TK_NAME)
	    {
	      fprintf (stderr, "Expected name after = expression.\n");
	      if (r != -1 && r != TK_NL)
		r = expect_newline ("SYMBOL");
	      return (r == -1 ? 0 : 1);
	    }
	  cur_libsymbol = unifyStr (t_buf);
	}
      else if (r == TK_EQUALEQUAL)
	{
	  r = lexit2 ();
	  if (r != TK_NAME)
	    {
	      fprintf (stderr, "Expected name after == expression.\n");
	      if (r != -1 && r != TK_NL)
		r = expect_newline ("SYMBOL");
	      return (r == -1 ? 0 : 1);
	    }
	  cur_alias = unifyStr (t_buf);
	}
      else
	{
	  fprintf (stderr, "Unknown token ,%s'.\n", t_buf);
	}
    }

    addSymbol (cur_symbol, cur_libsymbol, cur_alias, cur_data);
  }

  return (r != -1 ? 1 : 0);
}

void addSymbol (const char *sym, const char *libsym, const char *alias, int is_data)
{
  sSymbol *n;

  n = (sSymbol *) malloc (sizeof (sSymbol));
  n->next = NULL;
  n->sym = sym;
  n->libsym = libsym;
  n->alias = alias;
  n->is_data = is_data;
  n->subs = NULL;

  if (t_lastsym)
    t_lastsym->next = n;
  else
    t_sym = n;
  t_lastsym = n;
}

void sortSymbols (void)
{
  sSymbol *p = NULL, *c = t_sym;

  while (c != NULL)
    {
      if (c->alias[0] != 0)
      {
	sSymbol *l = NULL, *r = t_sym;
	while (r != NULL && r->sym != c->alias)
	{
	  l = r; r = r->next;
	}
	if (!r)
	  {
	    addSymbol (r->alias, unifyStr (""), unifyStr (""), 1);
	    r = t_lastsym;
	  }
	if (!p)
	  t_sym = c->next;
	else
	  p->next = c->next;
	c->next = r->subs;
	r->subs = c;
	c = t_sym; p = NULL;
	continue;
      }
      p = c;
      c = c->next;
    }
}

void dumpSymbols (void)
{
  sSymbol *l, *i;

  l = t_sym;
  while (l != NULL)
  {
    fprintf (stdout, "Symbol: ,%s'", l->sym);
    if (l->is_data) fprintf (stdout, " DATA");
    if (l->subs) {
      i = l->subs;
      fprintf (stdout, " aliases {");
      while (i != NULL)
	{
	  fprintf (stdout, " %s", i->sym);
	  if (i->is_data) fprintf (stdout, ":DATA");
	  i = i->next;
	}
      fprintf (stdout, " }");
    }
    fprintf (stdout, "\n");
    l = l->next;
  }
}

int main()
{
  int r;
  t_in = stdin;

  addCh (-1);

  while (parseit ())
    {
    }

  sortSymbols ();
  dumpSymbols ();
  outputSyms ();
  return 0;
}