shithub: rgbds

ref: c0a9cf79a32d93079b471ad61b767b538d1213c1
dir: /src/asm/lexer.c/

View raw version
#include	"asm.h"
#include	"lexer.h"
#include	"types.h"
#include	"main.h"
#include	"rpn.h"
#include	"asmy.h"
#include	"fstack.h"
#include	<stdio.h>
#include	<stdlib.h>
#include	<string.h>
#include	<ctype.h>

struct sLexString
{
	char	*tzName;
	ULONG	nToken;
	ULONG	nNameLength;
	struct	sLexString	*pNext;
};

#define	pLexBuffer		(pCurrentBuffer->pBuffer)
#define	nLexBufferLeng	(pCurrentBuffer->nBufferSize)

#define	SAFETYMARGIN	1024

extern ULONG symvaluetostring (char *dest, char *s);

struct	sLexFloat	tLexFloat[32];
struct	sLexString	*tLexHash[LEXHASHSIZE];
YY_BUFFER_STATE	pCurrentBuffer;
ULONG	yyleng;
ULONG	nLexMaxLeng;

ULONG	tFloatingSecondChar[256];
ULONG	tFloatingFirstChar[256];
ULONG	tFloatingChars[256];
ULONG	nFloating;
enum	eLexerState	lexerstate=LEX_STATE_NORMAL;

#define	AtLineStart	pCurrentBuffer->oAtLineStart

#ifdef	__GNUC__
void	strupr( char *s )
{
	while( *s )
	{
		*s=toupper(*s);
		s+=1;
	}
}

void	strlwr( char *s )
{
	while( *s )
	{
		*s=tolower(*s);
		s+=1;
	}
}

#endif
void	yyskipbytes( ULONG count )
{
	pLexBuffer+=count;
}

void	yyunputbytes( ULONG count )
{
	pLexBuffer-=count;
}

void	yyunput( char c )
{
	*(--pLexBuffer)=c;
}

void	yyunputstr( char *s )
{
	SLONG	i;

	i=strlen(s)-1;

	while( i>=0 )
		yyunput( s[i--] );
}

void	yy_switch_to_buffer( YY_BUFFER_STATE buf )
{
	pCurrentBuffer=buf;
}

void	yy_set_state( enum eLexerState i )
{
	lexerstate=i;
}

void	yy_delete_buffer( YY_BUFFER_STATE buf )
{
	free( buf->pBufferStart-SAFETYMARGIN );
	free( buf );
}

YY_BUFFER_STATE	yy_scan_bytes( char *mem, ULONG size )
{
	YY_BUFFER_STATE	pBuffer;

	if( (pBuffer=(YY_BUFFER_STATE)malloc(sizeof(struct yy_buffer_state)))!=NULL )
	{
		if( (pBuffer->pBuffer=pBuffer->pBufferStart=(char *)malloc(size+1+SAFETYMARGIN))!=NULL )
		{
			pBuffer->pBuffer+=SAFETYMARGIN;
			pBuffer->pBufferStart+=SAFETYMARGIN;
			memcpy( pBuffer->pBuffer, mem, size );
			pBuffer->nBufferSize=size;
			pBuffer->oAtLineStart=1;
			pBuffer->pBuffer[size]=0;
			return( pBuffer );
		}
	}

	fatalerror( "Out of memory!" );
	return( NULL );
}

YY_BUFFER_STATE	yy_create_buffer( FILE *f )
{
	YY_BUFFER_STATE pBuffer;

	if( (pBuffer=(YY_BUFFER_STATE)malloc(sizeof(struct yy_buffer_state)))!=NULL )
	{
	    ULONG   size;

		fseek (f, 0, SEEK_END);
		size = ftell (f);
		fseek (f, 0, SEEK_SET);

		if( (pBuffer->pBuffer=pBuffer->pBufferStart=(char *)malloc(size+2+SAFETYMARGIN))!=NULL )
		{
			char	*mem;
			ULONG   instring = 0;

			pBuffer->pBuffer+=SAFETYMARGIN;
			pBuffer->pBufferStart+=SAFETYMARGIN;

			size=fread( pBuffer->pBuffer, sizeof (UBYTE), size, f );

			pBuffer->pBuffer[size]='\n';
			pBuffer->pBuffer[size+1]=0;
			pBuffer->nBufferSize=size+1;

			mem=pBuffer->pBuffer;

			while( *mem )
			{
				if( *mem=='\"' )
					instring=1-instring;

				if( instring )
				{
					mem+=1;
				}
				else
				{
					if( (mem[0]==10 && mem[1]==13)
					||	(mem[0]==13 && mem[1]==10) )
					{
						mem[0]=' ';
						mem[1]='\n';
						mem+=2;
					}
					else if( mem[0]==10 || mem[0]==13 )
					{
						mem[0]='\n';
						mem+=1;
					}
					else if( mem[0]=='\n' && mem[1]=='*' )
					{
						mem+=1;
						while( !(*mem == '\n' || *mem == '\0') )
							*mem++=' ';
					}
					else if( *mem==';' )
					{
						while( !(*mem == '\n' || *mem == '\0') )
							*mem++=' ';
					}
					else
						mem+=1;
				}
			}

			pBuffer->oAtLineStart=1;
			return( pBuffer );
		}
	}

	fatalerror( "Out of memory!" );
	return( NULL );
}

ULONG	lex_FloatAlloc( struct sLexFloat *tok )
{
	tLexFloat[nFloating]=(*tok);

	return( 1<<(nFloating++) );
}

void	lex_FloatDeleteRange( ULONG id, UWORD start, UWORD end )
{
    while( start<=end )
    {
		tFloatingChars[start]&=~id;
		start+=1;
    }
}

void	lex_FloatAddRange( ULONG id, UWORD start, UWORD end )
{
    while( start<=end )
    {
		tFloatingChars[start]|=id;
		start+=1;
    }
}

void	lex_FloatDeleteFirstRange( ULONG id, UWORD start, UWORD end )
{
    while( start<=end )
    {
		tFloatingFirstChar[start]&=~id;
		start+=1;
    }
}

void	lex_FloatAddFirstRange( ULONG id, UWORD start, UWORD end )
{
    while( start<=end )
    {
		tFloatingFirstChar[start]|=id;
		start+=1;
    }
}

void	lex_FloatDeleteSecondRange( ULONG id, UWORD start, UWORD end )
{
    while( start<=end )
    {
		tFloatingSecondChar[start]&=~id;
		start+=1;
    }
}

void	lex_FloatAddSecondRange( ULONG id, UWORD start, UWORD end )
{
    while( start<=end )
    {
		tFloatingSecondChar[start]|=id;
		start+=1;
    }
}

struct	sLexFloat	*lexgetfloat( ULONG id )
{
    ULONG   r=0,
            mask=1;

    if( id==0 )
	return( NULL );

    while( (id&mask)==0 )
    {
		mask<<=1;
		r+=1;
    }

    return( &tLexFloat[r] );
}

ULONG	lexcalchash( char *s )
{
    ULONG	r=0;

    while( *s )
    {
		r=((r<<1)+(toupper(*s)))%LEXHASHSIZE;
		s+=1;
    }

    return( r );
}

void	lex_Init( void )
{
	ULONG   i;

	for( i=0; i<LEXHASHSIZE; i+=1)
	{
		tLexHash[i]=NULL;
	}

	for( i=0; i<256; i+=1 )
	{
		tFloatingFirstChar[i]=0;
		tFloatingSecondChar[i]=0;
		tFloatingChars[i]=0;
	}

	nLexMaxLeng=0;
	nFloating=0;
}

void	lex_AddStrings( struct sLexInitString *lex )
{
    while( lex->tzName )
    {
		struct sLexString 	**ppHash;
	    ULONG				hash;

		ppHash = &tLexHash[hash=lexcalchash (lex->tzName)];
		while (*ppHash)
		    ppHash = &((*ppHash)->pNext);

//   printf( "%s has hashvalue %d\n", lex->tzName, hash );

		if( ((*ppHash)=(struct sLexString *)malloc(sizeof(struct sLexString)))!=NULL )
		{
		    if( ((*ppHash)->tzName=(char *)strdup(lex->tzName))!=NULL )
		    {
				(*ppHash)->nNameLength = strlen (lex->tzName);
				(*ppHash)->nToken = lex->nToken;
				(*ppHash)->pNext = NULL;

				strupr ((*ppHash)->tzName);

				if ((*ppHash)->nNameLength > nLexMaxLeng)
				    nLexMaxLeng = (*ppHash)->nNameLength;

		    }
		    else
				fatalerror ("Out of memory!");
		}
		else
		    fatalerror ("Out of memory!");

		lex += 1;
    }
}

ULONG   yylex (void)
{
	ULONG	hash,
			maxlen;
	char	*s;
	struct sLexString *pLongestFixed = NULL;
	ULONG   nFloatMask,
	        nOldFloatMask,
	        nFloatLen;
	ULONG   linestart = AtLineStart;

	switch( lexerstate )
	{
		case LEX_STATE_NORMAL:
			AtLineStart = 0;

		  scanagain:

		    while (*pLexBuffer == ' ' || *pLexBuffer == '\t')
		    {
				linestart = 0;
				pLexBuffer += 1;
		    }

		    if (*pLexBuffer == 0)
		    {
				if (yywrap () == 0)
				{
				    linestart = AtLineStart;
				    AtLineStart = 0;
				    goto scanagain;
				}
		    }

		    s = pLexBuffer;
		    nOldFloatMask = nFloatLen = 0;
		    nFloatMask = tFloatingFirstChar[*s++];
		    while (nFloatMask && nFloatLen < nLexBufferLeng)
		    {
				nFloatLen += 1;
				nOldFloatMask = nFloatMask;
				if (nFloatLen == 1)
				    nFloatMask &= tFloatingSecondChar[*s++];
				else
				    nFloatMask &= tFloatingChars[*s++];
		    }

		    maxlen = nLexBufferLeng;
		    if (nLexMaxLeng < maxlen)
				maxlen = nLexMaxLeng;

		    yyleng = 0;
		    hash = 0;
		    s = pLexBuffer;
		    while (yyleng < nLexMaxLeng)
		    {
				yyleng += 1;
				hash = ((hash << 1) + (toupper (*s))) % LEXHASHSIZE;
				s+=1;
				if (tLexHash[hash])
				{
				    struct sLexString *lex;

				    lex = tLexHash[hash];
				    while (lex)
				    {
						if (lex->nNameLength == yyleng)
						{
						    if (strnicmp (pLexBuffer, lex->tzName, yyleng) == 0)
						    {
								pLongestFixed = lex;
						    }
						}
						lex = lex->pNext;
				    }
				}

		    }

		    if (nFloatLen == 0 && pLongestFixed == NULL)
		    {
				if (*pLexBuffer == '"')
				{
				    ULONG   index = 0;

				    pLexBuffer += 1;
				    while ((*pLexBuffer != '"') && (*pLexBuffer != '\n'))
				    {
						char    ch,
						       *marg;

						if ((ch = *pLexBuffer++) == '\\')
						{
						    switch (ch = (*pLexBuffer++))
						    {
								case 'n':
								    ch = '\n';
								    break;
								case 't':
								    ch = '\t';
								    break;
								case '0':
								case '1':
								case '2':
								case '3':
								case '4':
								case '5':
								case '6':
								case '7':
								case '8':
								case '9':
								    if( (marg=sym_FindMacroArg(ch-'0'))!=NULL )
								    {
										while (*marg)
										    yylval.tzString[index++] = *marg++;
										ch = 0;
								    }
								    break;
								case '@':
								    if( (marg=sym_FindMacroArg(-1))!=NULL )
								    {
										while (*marg)
										    yylval.tzString[index++] = *marg++;
										ch = 0;
								    }
								    break;
						    }
						}
						else if (ch == '{')
						{
						    char    sym[MAXSYMLEN];
						    int     i = 0;

						    while ((*pLexBuffer != '}') && (*pLexBuffer != '"') && (*pLexBuffer != '\n'))
						    {
								if ((ch = *pLexBuffer++) == '\\')
								{
								    switch (ch = (*pLexBuffer++))
								    {
										case '0':
										case '1':
										case '2':
										case '3':
										case '4':
										case '5':
										case '6':
										case '7':
										case '8':
										case '9':
										    if( (marg=sym_FindMacroArg(ch-'0'))!=NULL )
										    {
												while (*marg)
												    sym[i++] = *marg++;
												ch = 0;
										    }
										    break;
										case '@':
										    if( (marg=sym_FindMacroArg(-1))!=NULL )
										    {
												while (*marg)
												    sym[i++] = *marg++;
												ch = 0;
										    }
										    break;
								    }
								}
								else
									sym[i++] = ch;
						    }

						    sym[i] = 0;
						    index += symvaluetostring (&yylval.tzString[index], sym);
						    if (*pLexBuffer == '}')
								pLexBuffer += 1;
						    else
								yyerror ("Missing }");
						    ch = 0;
						}

						if (ch)
						    yylval.tzString[index++] = ch;
				    }

				    yylval.tzString[index++] = 0;

				    if (*pLexBuffer == '\n')
						yyerror ("Unterminated string");
				    else
						pLexBuffer += 1;

				    return (T_STRING);
				}
				else if (*pLexBuffer == '{')
				{
				    char    sym[MAXSYMLEN],
							ch,
							*marg;
				    int     i = 0;

				    pLexBuffer += 1;

				    while ((*pLexBuffer != '}') && (*pLexBuffer != '\n'))
				    {
						if ((ch = *pLexBuffer++) == '\\')
						{
							switch (ch = (*pLexBuffer++))
							{
								case '0':
								case '1':
								case '2':
								case '3':
								case '4':
								case '5':
								case '6':
								case '7':
								case '8':
								case '9':
									if( (marg=sym_FindMacroArg(ch-'0'))!=NULL )
									{
										while (*marg)
											sym[i++] = *marg++;
										ch = 0;
									}
									break;
								case '@':
									if( (marg=sym_FindMacroArg(-1))!=NULL )
									{
										while (*marg)
											sym[i++] = *marg++;
										ch = 0;
									}
									break;
							}
						}
						else
							sym[i++] = ch;
				    }
				    sym[i] = 0;
				    symvaluetostring (yylval.tzString, sym);
				    if (*pLexBuffer == '}')
						pLexBuffer += 1;
				    else
						yyerror ("Missing }");

				    return (T_STRING);
				}
				else
				{
				    if (*pLexBuffer == '\n')
						AtLineStart = 1;

				    yyleng = 1;
				    return (*pLexBuffer++);
				}
		    }

		    if (nFloatLen == 0)
		    {
				yyleng = pLongestFixed->nNameLength;
				pLexBuffer += yyleng;
				return (pLongestFixed->nToken);
		    }

		    if (pLongestFixed == NULL)
		    {
				struct sLexFloat *tok;

				tok = lexgetfloat (nOldFloatMask);
				yyleng = nFloatLen;
				if (tok->Callback)
				{
				    if (tok->Callback (pLexBuffer, yyleng) == 0)
						goto scanagain;
				}

				if (tok->nToken == T_ID && linestart)
				{
				    pLexBuffer += yyleng;
				    return (T_LABEL);
				}
				else
				{
				    pLexBuffer += yyleng;
				    return (tok->nToken);
				}
		    }

		    if (nFloatLen > pLongestFixed->nNameLength)
		    {
				struct sLexFloat *tok;

				tok = lexgetfloat (nOldFloatMask);
				yyleng = nFloatLen;
				if (tok->Callback)
				{
				    if (tok->Callback (pLexBuffer, yyleng) == 0)
						goto scanagain;
				}

				if (tok->nToken == T_ID && linestart)
				{
				    pLexBuffer += yyleng;
				    return (T_LABEL);
				}
				else
				{
				    pLexBuffer += yyleng;
				    return (tok->nToken);
				}
		    }
		    else
		    {
				yyleng = pLongestFixed->nNameLength;
				pLexBuffer += yyleng;
				return (pLongestFixed->nToken);
		    }
			break;

		case LEX_STATE_MACROARGS:
			{
				ULONG   index = 0;

			    while (*pLexBuffer == ' ' || *pLexBuffer == '\t')
			    {
					linestart = 0;
					pLexBuffer += 1;
			    }

				while(	(*pLexBuffer != ',')
				&&		(*pLexBuffer != '\n') )
				{
					char    ch,
							*marg;

					if ((ch = *pLexBuffer++) == '\\')
					{
						switch (ch = (*pLexBuffer++))
						{
							case 'n':
								ch = '\n';
								break;
							case 't':
								ch = '\t';
								break;
							case '0':
							case '1':
							case '2':
							case '3':
							case '4':
							case '5':
							case '6':
							case '7':
							case '8':
							case '9':
								if( (marg=sym_FindMacroArg(ch-'0'))!=NULL )
								{
									while (*marg)
										yylval.tzString[index++] = *marg++;
									ch = 0;
								}
								break;
							case '@':
								if( (marg=sym_FindMacroArg(-1))!=NULL )
								{
									while (*marg)
										yylval.tzString[index++] = *marg++;
									ch = 0;
								}
								break;
						}
					}
					else if (ch == '{')
					{
						char    sym[MAXSYMLEN];
						int     i = 0;

						while ((*pLexBuffer != '}') && (*pLexBuffer != '"') && (*pLexBuffer != '\n'))
						{
							if ((ch = *pLexBuffer++) == '\\')
							{
								switch (ch = (*pLexBuffer++))
								{
									case '0':
									case '1':
									case '2':
									case '3':
									case '4':
									case '5':
									case '6':
									case '7':
									case '8':
									case '9':
										if( (marg=sym_FindMacroArg(ch-'0'))!=NULL )
										{
											while (*marg)
												sym[i++] = *marg++;
											ch = 0;
										}
										break;
									case '@':
										if( (marg=sym_FindMacroArg(-1))!=NULL )
										{
											while (*marg)
												sym[i++] = *marg++;
											ch = 0;
										}
										break;
								}
							}
							else
								sym[i++] = ch;
						}
						sym[i] = 0;
						index += symvaluetostring (&yylval.tzString[index], sym);
						if (*pLexBuffer == '}')
							pLexBuffer += 1;
						else
							yyerror ("Missing }");
						ch = 0;
					}

					if (ch)
						yylval.tzString[index++] = ch;
				}

				if( index )
				{
					yyleng=index;
					yylval.tzString[index] = 0;
					if( *pLexBuffer=='\n' )
					{
						while( yylval.tzString[--index]==' ' )
						{
							yylval.tzString[index]=0;
							yyleng-=1;
						}
					}
					return (T_STRING);
				}
				else if( *pLexBuffer=='\n' )
				{
					pLexBuffer+=1;
					AtLineStart = 1;
				    yyleng = 1;
					return( '\n' );
				}
				else if( *pLexBuffer==',' )
				{
					pLexBuffer+=1;
					yyleng = 1;
					return( ',' );
				}
				else
				{
					yyerror( "INTERNAL ERROR IN YYLEX" );
					return( 0 );
				}
			}

			break;
	}

	yyerror( "INTERNAL ERROR IN YYLEX" );
	return( 0 );
}