usbloadergx/source/language/gettext.c

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <gctypes.h>
#include "gettext.h"

typedef struct _MSG
{
	u32 id;
	char* msgstr;
	struct _MSG *next;
} MSG;
static MSG *baseMSG=0;


#define HASHWORDBITS 32

/* Defines the so called `hashpjw' function by P.J. Weinberger
   [see Aho/Sethi/Ullman, COMPILERS: Principles, Techniques and Tools,
   1986, 1987 Bell Telephone Laboratories, Inc.]  */
static inline u32
hash_string (const char *str_param)
{
  u32 hval, g;
  const char *str = str_param;

  /* Compute the hash value for the given string.  */
  hval = 0;
  while (*str != '\0')
    {
      hval <<= 4;
      hval += (u8) *str++;
      g = hval & ((u32) 0xf << (HASHWORDBITS - 4));
      if (g != 0)
	{
	  hval ^= g >> (HASHWORDBITS - 8);
	  hval ^= g;
	}
    }
  return hval;
}

/* Expand some escape sequences found in the argument string.  */
static char *
expand_escape (const char *str)
{
	char *retval, *rp;
	const char *cp = str;

	retval = (char *) malloc (strlen (str)+1);
	if(retval==NULL) return NULL;
	rp = retval;

	while (cp[0] != '\0' && cp[0] != '\\')
		*rp++ = *cp++;
	if(cp[0] == '\0')
		goto terminate;
	do
	{
			
		/* Here cp[0] == '\\'.  */
		switch (*++cp)
		{
		case '\"':		/* " */
			*rp++ = '\"';
			++cp;
			break;
		case 'a':		/* alert */
			*rp++ = '\a';
			++cp;
			break;
		case 'b':		/* backspace */
			*rp++ = '\b';
			++cp;
			break;
		case 'f':		/* form feed */
			*rp++ = '\f';
			++cp;
			break;
		case 'n':		/* new line */
			*rp++ = '\n';
			++cp;
			break;
		case 'r':		/* carriage return */
			*rp++ = '\r';
			++cp;
			break;
		case 't':		/* horizontal tab */
			*rp++ = '\t';
			++cp;
			break;
		case 'v':		/* vertical tab */
			*rp++ = '\v';
			++cp;
			break;
		case '\\':
			*rp = '\\';
			++cp;
			break;
		case '0': case '1': case '2': case '3':
		case '4': case '5': case '6': case '7':
			{
				int ch = *cp++ - '0';

				if (*cp >= '0' && *cp <= '7')
				{
					ch *= 8;
					ch += *cp++ - '0';

					if (*cp >= '0' && *cp <= '7')
					{
						ch *= 8;
						ch += *cp++ - '0';
					}
				}
				*rp = ch;
			}
			break;
		default:
			*rp = '\\';
			break;
		}

		while (cp[0] != '\0' && cp[0] != '\\')
			*rp++ = *cp++;
    }
	while (cp[0] != '\0');

	/* Terminate string.  */
terminate:
	*rp = '\0';
	return retval;
}

static MSG *findMSG(u32 id)
{
	MSG *msg;
	for(msg=baseMSG; msg; msg=msg->next)
	{
		if(msg->id == id)
			return msg;
	}
	return NULL;
}

static MSG *setMSG(const char *msgid, const char *msgstr)
{
	u32 id = hash_string(msgid);
	MSG *msg = findMSG(id);
	if(!msg)
	{
		msg = (MSG *)malloc(sizeof(MSG));
		msg->id		= id;
		msg->msgstr = NULL;
		msg->next	= baseMSG;
		baseMSG		= msg;
	}
	if(msg)
	{
		if(msgstr)
		{
			if(msg->msgstr) free(msg->msgstr);
			//msg->msgstr = strdup(msgstr);
			msg->msgstr = expand_escape(msgstr);
		}
		return msg;
	}
	return NULL;
}
void gettextCleanUp(void)
{
	while(baseMSG)
	{
		MSG *nextMsg =baseMSG->next;
		free(baseMSG->msgstr);
		free(baseMSG);
		baseMSG = nextMsg;
	}
}


bool gettextLoadLanguage(const char* langFile)
{
	FILE *f;
	char line[200];
	char *lastID=NULL;
	
	gettextCleanUp();
	f = fopen(langFile, "r");
	if(!f)
		return false;

	while (fgets(line, sizeof(line), f))
	{
		// lines starting with # are comments
		if (line[0] == '#')
			continue;
		else if (strncmp(line, "msgid \"", 7) == 0)
		{
			char *msgid, *end;
			if(lastID) { free(lastID); lastID=NULL;}
			msgid = &line[7];
			end = strrchr(msgid, '"');
			if(end && end-msgid>1)
			{
				*end = 0;
				lastID = strdup(msgid);
			}
		}
		else if (strncmp(line, "msgstr \"", 8) == 0)
		{
			char *msgstr, *end;
			
			if(lastID == NULL)
				continue;
			
			msgstr = &line[8];
			end = strrchr(msgstr, '"');
			if(end && end-msgstr>1)
			{
				*end = 0;
				setMSG(lastID, msgstr);
			}
			free(lastID);
			lastID=NULL;
		}
		
	}

	fclose(f);
	return true;
}
const char *gettext(const char *msgid)
{
	MSG *msg = findMSG(hash_string(msgid));
	if(msg && msg->msgstr) return msg->msgstr;
	return msgid;
}