/* res.cxx
     $Id: res.cxx,v 1.16 1998/10/21 21:13:57 elf Exp $

   written by Marc Singer
   14 May 1997

   This file is part of the project XO.  See the file README for
   more information.

   Copyright (C) 1997 Marc Singer

   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 2 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
   in a file called COPYING along with this program; if not, write to
   the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA
   02139, USA.

   -----------
   DESCRIPTION
   -----------

*/

//#define USE_TEST

#include "standard.h"
#include "ctype.h"
#if defined (HAVE_FCNTL_H)
# include "fcntl.h"
#endif
#if defined (HAVE_MEMORY_H)
# include "memory.h"
#endif

#define IS_PARSER
#include "lres.h"
#include "res_y.hxx"

#define LONG_PRIME_MAX		(LONG_MAX/10)
#define LONG_PRIME_MAX_REM	(LONG_MAX - LONG_PRIME_MAX*10)
//#define TEST_LEXER

#define CB_NODES		(0x10000)

#define DPRINTF(a)	printf a

void* LResNode::g_pvBase;
void* LResNode::g_pvAlloc;
int*  LResNode::g_piResource;

void* LResNode::alloc (int cb, void* pv)
{
  if (!g_pvBase) {
    g_pvBase = g_pvAlloc = malloc (CB_NODES);
    if (!g_pvBase)
      return NULL;
    g_piResource = (int*) alloc (sizeof (int), NULL);
  }

  void* pvNew = g_pvAlloc;
  if (pv)
    memcpy (pvNew, pv, cb);
  else
    memset (pvNew, 0, cb);
  cb = ((cb + 3) & ~3);

  g_pvAlloc = (unsigned8*) g_pvAlloc + cb;
  return pvNew;
}


/* safe_atol

   converts a string to a long in a safe manner, checking for errors.

*/

int safe_atol (char* sz, signed long* pl)
{
  if (sz[0] == '0' && tolower (sz[1]) == 'x') {
    unsigned long l = 0;
    if (strlen (sz) > 10)
      return 1;			// Overflow on unsigned
    for (sz += 2; *sz; ++sz) {
      switch (tolower (*sz)) {
      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
	l = (l << 4) + (*sz - '0');
	break;
      case 'a':
      case 'b':
      case 'c':
      case 'd':
      case 'e':
      case 'f':
	l = (l << 4) + (tolower (*sz) - 'a' + 10);
	break;
      default:
//	assert (false);
	break;
      }  /* switch */
    }  /* for */
    *pl = (long) l;
  }  /* if */
  else {
    register long l = 0;
    int fSigned = 0;

    for (; *sz; ++sz) {
      switch (*sz) {
      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
	/*      DPRINTF (("%d %d %d %d\n", l, *sz - '0', LONG_PRIME_MAX,
		LONG_PRIME_MAX_REM)); */
	if (       l         <  LONG_PRIME_MAX
	    || (   l         == LONG_PRIME_MAX
		&& *sz - '0' <  LONG_PRIME_MAX_REM))
	  l = l*10 + *sz - '0';
	else
	  return 1;		/* Overflow on unsigned number */
	break;

      case '-':
	fSigned = 1;
      case '+':
	break;
      }  /* switch */
    }  /* while */
    if (fSigned && l > LONG_MAX - 1)
      return 2;			/* Overflow on signed number */
    *pl = fSigned ? -l : l;
  }  /* else */
  return 0;
}  /* safe_atol */


int safe_atof (char* sz, float* pr)
{
  *pr = atof (sz);
  return 0;
}


bool LResNode::is_invocation (const char* szKeyword, int id)
{
  return (   m_type						== INVOCATION
	  && m_v.pNode
	  && m_v.pNode->m_type					== KEYWORD
	  && m_v.pNode->m_v.sz
	  && !strcasecmp (m_v.pNode->m_v.sz, szKeyword)
	  && m_v.pNode->m_pNode
	  && m_v.pNode->m_pNode->m_type				== ARGLIST
	  && m_v.pNode->m_pNode->m_v.pNode
	  && m_v.pNode->m_pNode->m_v.pNode->m_type		== INTEGER
	  && m_v.pNode->m_pNode->m_v.pNode->m_v.l		== id
	  );
}


bool LResNode::integer (int* pi)
{
  if (m_type != INTEGER)
    return false;
  *pi = m_v.l;
  return true;
}

bool LResNode::real (float* pr)
{
  if (m_type != REAL)
    return false;
  *pr = m_v.r;
  return true;
}

bool LResNode::string (char** psz)
{
  if (m_type != STRING)
    return false;
  *psz = m_v.sz;
  return true;
}


/* find_resources

   returns a pointer to the first invocation contained by this
   invocation.  This function recurses into the current invocation.

*/

LResNode* LResNode::find_resources (void)
{
  if (m_type != INVOCATION)
    return NULL;
  for (LResNode* pNode = m_v.pNode; pNode; pNode = pNode->m_pNode)
    if (pNode->m_type == RESOURCE)
      return pNode->m_v.pNode;
  return NULL;
}

/* LResNode::keyword

   returns a pointer to the keyword string for the invocation.  The
   return value is NULL if the node is not an invocation.

*/

char* LResNode::keyword (void)
{
  if (    m_type != INVOCATION
      || !m_v.pNode
      ||  m_v.pNode->m_type != KEYWORD)
    return NULL;
  return m_v.pNode->m_v.sz;
}


/* LResNode::locate

   locates a typed resource with the given ID.  It is required that
   all resources have the ID as the first argument if they are found
   with this primitive.

*/

LResNode* LResNode::locate (const char* szInvocation, int id)
{
  LResNode* pNode = (LResNode*) ((unsigned8*) g_pvBase + *g_piResource);
  if (pNode->m_v.pNode)
    pNode = pNode->m_v.pNode;

  for (; pNode; pNode = pNode->m_pNode) {
    if (pNode->is_invocation (szInvocation, id))
      return pNode;
  }

  return NULL;
}


/* LResNode::enum_args

   enumerates the argument vector for an invocation.  On the first
   call, pass the pointer to the invocation.  For successive calls,
   pass the pointer returned by the function.

*/


LResNode* LResNode::enum_args (void)
{
  if (!this)
    return NULL;
				// Initial case
  if (m_type == INVOCATION) {
    for (LResNode* pNode = m_v.pNode; pNode; pNode = pNode->m_pNode)
      if (pNode->m_type == ARGLIST)
	return pNode->m_v.pNode;
    return NULL;
  }

				// Iterative case
  return m_pNode;
}


void LResNode::emit (int index)
{
/*   DPRINTF (("[emit 0x%x]", (char*) pNode - (char*) g_pvNodeAlloc)); */

  switch (m_type) {
  case ARGLIST:
    DPRINTF ((" ("));
    for (LResNode* pNode = m_v.pNode; pNode; pNode = pNode->m_pNode)
      pNode->emit (index + 1);
    DPRINTF ((" )"));
    break;
  case INVOCATION:
    DPRINTF (("%*.*s", index, index, ""));
    for (LResNode* pNode = m_v.pNode; pNode; pNode = pNode->m_pNode)
      pNode->emit (index + 1);
    DPRINTF (("\n"));
    break;
  case KEYWORD:
    DPRINTF (("%s", m_v.sz));
    break;
  case INTEGER:
    DPRINTF ((" %ld", m_v.l));
    break;
  case REAL:
    DPRINTF ((" %g", m_v.r));
    break;
  case STRING:
    DPRINTF ((" \"%s\"", m_v.sz));
    break;
  case RESOURCE:
    if (index > 0)
      DPRINTF ((" {\n"));
    for (LResNode* pNode = m_v.pNode; pNode; pNode = pNode->m_pNode) {
      pNode->emit (index + 1);
/*      DPRINTF (("[ in resource 0x%x=>0x%x]",
	      (char*) pNode - (char*) g_pvNodeAlloc,
	      (char*) pNode->m_pNode - (char*) g_pvNodeAlloc));
*/
    }
    if (index > 0)
      DPRINTF (("%*.*s}", index - 1, index - 1, ""));
    break;
  }
}

void LResNode::generate (LResNode* pNode)
{
  *g_piResource = (unsigned8*) pNode - (unsigned8*) g_pvBase;

				// Emit all of the resources
  //  for (; pNode; pNode = pNode->m_pNode)
  //    emit (pNode, -1);

  DPRINTF (("resource templates require %d bytes\n", 
	    int ((unsigned8*) g_pvAlloc - (unsigned8*) g_pvBase)));

  {
    int fh = open ("resources", O_WRONLY | O_CREAT | O_TRUNC, 0660);
    write (fh, g_pvBase, (unsigned8*) g_pvAlloc - (unsigned8*) g_pvBase);
    close (fh);
  }

  //  pNode = locate ("menu", 1);
  //  pNode->emit (0);
}


/* _fixup

   reverses the order of the argument and resource lists.  These lists
   are collected in reverse order because of the way that the parser
   reduces the grammer.  Yes, we could fix it, but the overhead of
   reordering is low.

   Note that the invocation itself is not reordered, but it must be
   enumerated in order to reorder the argument list, the possible
   resource list. 

*/

void LResNode::_fixup (void)
{
  switch (m_type) {
  default:
    break;
  case ARGLIST:
  case RESOURCE:
    {
      LResNode* pNodeNext = NULL;
      LResNode* pNodeLink;
      for (LResNode* pNodeStep = m_v.pNode; pNodeStep; 
	   pNodeStep = pNodeLink) {
	pNodeLink = pNodeStep->m_pNode;
	pNodeStep->m_pNode = pNodeNext;
	pNodeNext = pNodeStep;
      }	
      m_v.pNode = pNodeNext;
    }
  case INVOCATION:
    for (LResNode* pNode = m_v.pNode; pNode; pNode = pNode->m_pNode)
      pNode->_fixup ();
    break;
  }
}


void LResNode::fixup (LResNode* pNode) 
{
  for (; pNode; pNode = pNode->m_pNode)
    pNode->_fixup ();
}

/* as_bool

   returns a boolean value interpretation for a X Resource Manager
   value.  This is a convenience feature to make the specification of
   booleans simple.  The default is returned if the value is not
   valid.

*/

bool as_bool (const XrmValue& value, bool fDefault)
{
  if (!value.addr || !value.size)
    return fDefault;
  
  if (   *value.addr == 't' || *value.addr == 'T'
      || *value.addr == 'y' || *value.addr == 'Y' 
      || *value.addr == '1')
    return true;
  if (   *value.addr == 'f' || *value.addr == 'F'
      || *value.addr == 'n' || *value.addr == 'N' 
      || *value.addr == '0')
    return false;
  return fDefault;
}


extern "C" int yywrap (void)
{
  return 1;
}  /* yywrap */


#if defined (USE_TEST)

int main (int /* argc */, char** /* argv */)
{
  yyin = stdin;

#if defined (TEST_LEXER)
  int result;
  while (result = yylex ()) {
    switch (result) {
    case KEYWORD:
      DPRINTF ((" <%s>", yylval.sz));
      break;
    case PO:
      DPRINTF ((" PO"));
      break;
    case PC:
      DPRINTF ((" PC\n"));
      break;
    case BO:
      DPRINTF ((" BO\n"));
      break;
    case BC:
      DPRINTF ((" BC\n"));
      break;
    case QUOTE:
      DPRINTF ((" QUOTE"));
      break;
    case INTEGER:
      DPRINTF ((" INTEGER %d", yylval.l));
      break;
    case REAL:
      DPRINTF ((" REAL"));
      break;
    case STRING:
      DPRINTF ((" STRING '%s'", yylval.sz));
      break;
    case ERROR:
      DPRINTF ((" ERROR\n"));
      break;
    default:
      if (isprint (result))
	DPRINTF ((" '%c'", result));
      else
	DPRINTF ((" [%d]", result));
      break;
    }
  }
#else

  yyparse ();
#endif

#if 0
  LResNode* pNodeMenu = LResNode::locate ("dialog", 1);
  for (LResNode* pNode = pNodeMenu->find_resources (); pNode; 
       pNode = pNode->next ()) {
    pNode->emit (1);
    for (LResNode* pNodeArg = pNode; pNodeArg = pNodeArg->enum_args (); ) {
      pNodeArg->emit (3);
    }
  }
#endif

}

#endif
