Exemple #1
0
// GENARG
// GENARG ',' GENARGS
BOOL CLRTypeName::TypeNameParser::GENARGS()
{
    IfFalseReturn(TokenIs(TypeNameGENARGS));

    IfFalseReturn(GENARG());

    if (TokenIs(TypeNameComma))
    {
        NextToken();
        IfFalseReturn(GENARGS());
    }

    return TRUE;
}
Exemple #2
0
// id
// id '+' NESTNAME
BOOL CLRTypeName::TypeNameParser::NESTNAME()
{
    IfFalseReturn(TokenIs(TypeNameNESTNAME));

    GetIdentifier(m_pTypeName->AddName(), TypeNameId);

    NextToken();
    if (TokenIs(TypeNamePlus))
    {
        NextToken();
        IfFalseReturn(NESTNAME());
    }

    return TRUE;
}
Exemple #3
0
void Expect(char *str)
{
	GetToken();
	if (TokenIs(str))
	{
		return;
	}
	vcerr("error: %s expected, %s got", str, tok.ident); //token);
}
Exemple #4
0
// fusionName
BOOL CLRTypeName::TypeNameParser::ASSEMSPEC()
{
    IfFalseReturn(TokenIs(TypeNameASSEMSPEC));

    GetIdentifier(m_pTypeName->GetAssembly(), TypeNameFusionName);

    NextToken();

    return TRUE;
}
Exemple #5
0
// *empty*
// '[' GENARGS ']'
BOOL CLRTypeName::TypeNameParser::GENPARAMS()
{
    if (!TokenIs(TypeNameGENPARAM))
    {
        return TRUE;
    }

    if (!NextTokenIs(TypeNameGENARGS))
    {
        return TRUE;
    }

    NextToken();
    IfFalseReturn(GENARGS());

    IfFalseReturn(TokenIs(TypeNameCloseSqBracket));
    NextToken();

    return TRUE;
}
Exemple #6
0
// NAME GENPARAMS QUALIFIER
BOOL CLRTypeName::TypeNameParser::FULLNAME()
{
    IfFalseReturn(TokenIs(TypeNameFULLNAME));
    IfFalseReturn(NAME());

    IfFalseReturn(GENPARAMS());

    IfFalseReturn(QUALIFIER());

    return TRUE;
}
Exemple #7
0
#include "stdafx.h"

#define IfFalseReturn(P) if (!P) return FALSE;

HRESULT CLRTypeName::ParseTypeName(LPCWSTR szTypeName, DWORD* pError, CLRTypeName** ppTypeName)
{
    if (!ppTypeName || !pError)
    {
        return E_INVALIDARG;
    }

    HRESULT hr = S_OK;

    *ppTypeName = NULL;
    *pError = (DWORD)-1;

    CLRTypeName* pTypeName = new CLRTypeName(szTypeName, pError);

    if (!pTypeName)
    {
        hr = E_OUTOFMEMORY;
    }
    else
    {
        pTypeName->AddRef();

        if (*pError != (DWORD)-1)
        {
            pTypeName->Release();
            hr = S_FALSE;
        }
        else
        {
            *ppTypeName = pTypeName;
        }
    }

    return hr;
}

INT32 CLRTypeName::GetCharacterInfoHelper(WCHAR c, INT32 CharInfoType)
{
    unsigned short result=0;
    if (!GetStringTypeEx(LOCALE_USER_DEFAULT, CharInfoType, &(c), 1, &result)) {
        _ASSERTE(!"This should not happen, verify the arguments passed to GetStringTypeEx()");
    }
    return(INT32)result;
}

BOOL CLRTypeName::NativeIsWhiteSpace(WCHAR c)
{
    if (c <= (WCHAR) 0x7F) // common case
    {
        BOOL result = (c == ' ') || (c == '\r') || (c == '\n') || (c == '\t') || (c == '\f') || (c == (WCHAR) 0x0B);

        ASSERT(result == ((GetCharacterInfoHelper(c, CT_CTYPE1) & C1_SPACE) != 0), "");

        return result;
    }

    // GetCharacterInfoHelper costs around 160 instructions
    return((GetCharacterInfoHelper(c, CT_CTYPE1) & C1_SPACE)!=0);
}

ULONG CLRTypeName::AddRef()
{
    m_count++;

    return m_count;
}

DWORD CLRTypeName::Release()
{
    m_count--;

    DWORD dwCount = m_count;
    if (dwCount == 0)
    {
        delete this;
    }

    return dwCount;
}

CLRTypeName::~CLRTypeName()
{
    for (ULONG i = m_genericArguments.Count(); i > 0; i--)
    {
        CLRTypeName* pGenericArgument = m_genericArguments.Element(i - 1);
        m_genericArguments.Remove(i - 1);
        pGenericArgument->Release();
    }

    for (ULONG i = m_names.Count(); i > 0; i--)
    {
        StringBuffer* pBuffer = m_names.Element(i - 1);
        m_names.Remove(i - 1);
        delete pBuffer;
    }
}

CLRTypeName* CLRTypeName::AddGenericArgument()
{
    CLRTypeName* pGenArg = new CLRTypeName();
    pGenArg->AddRef();

    pGenArg->m_bIsGenericArgument = TRUE;
    m_genericArguments.AddElement(pGenArg);
    return pGenArg;
}

CLRTypeName::TypeNameParser::TypeNameTokens CLRTypeName::TypeNameParser::LexAToken()
{
    if (m_nextToken == TypeNameIdentifier)
    {
        return TypeNamePostIdentifier;
    }

    if (m_nextToken == TypeNameEnd)
    {
        return TypeNameEnd;
    }

    if (*m_itr == L'\0')
    {
        return TypeNameEnd;
    }

    if (NativeIsWhiteSpace(*m_itr))
    {
        m_itr++;
        return LexAToken();
    }

    WCHAR c = *m_itr;
    m_itr++;
    switch(c)
    {
        case L',': return TypeNameComma;
        case L'[': return TypeNameOpenSqBracket;
        case L']': return TypeNameCloseSqBracket;
        case L'&': return TypeNameAmperstand;
        case L'*': return TypeNameAstrix;
        case L'+': return TypeNamePlus;
        case L'\\':
            m_itr--;
            return TypeNameIdentifier;
    }

    ASSERT(!CLRTypeName::IsTypeNameReservedChar(c), "");

    m_itr--;
    return TypeNameIdentifier;
}

BOOL CLRTypeName::TypeNameParser::GetIdentifier(StringBuffer* sszId, CLRTypeName::TypeNameParser::TypeNameIdentifiers identifierType)
{
    ASSERT(m_currentToken == TypeNameIdentifier && m_nextToken == TypeNamePostIdentifier, "");

    sszId->Clear();

    LPCWSTR start = m_currentItr;
    DynamicArray<LPCWSTR> m_escape;

    if (identifierType == TypeNameId)
    {
        do
        {
            switch (* m_currentItr ++)
            {
                case L',':
                case L'[':
                case L']':
                case L'&':
                case L'*':
                case L'+':
                case L'\0':
                    goto done;

                case L'\\':
                    m_escape.AddElement(m_currentItr - 1);

                    if (!CLRTypeName::IsTypeNameReservedChar(*m_currentItr) || *m_currentItr == '\0')
                    {
                        return FALSE;
                    }

                    m_currentItr++;
                    break;

                default:
                    break;
            }
        }
        while(true);

done:
        m_currentItr--;
    }
    else if (identifierType == TypeNameFusionName)
    {
        while(*m_currentItr != L'\0')
        {
            m_currentItr++;
        }
    }
    else if (identifierType == TypeNameEmbeddedFusionName)
    {
        for (; (*m_currentItr != L'\0') && (*m_currentItr != L']'); m_currentItr++)
        {
            if (*m_currentItr == L'\\')
            {
                if (*(m_currentItr + 1) == L']')
                {
                    m_escape.AddElement(m_currentItr);
                    m_currentItr ++;
                    continue;
                }
            }

            if (*m_currentItr == '\0')
            {
                return FALSE;
            }
        }
        if (*m_currentItr == L'\0')
        {
            return FALSE;
        }
    }
    else
    {
        return FALSE;
    }

    sszId->AppendWithLength(start, (size_t)(m_currentItr - start));

    for (ULONG i = m_escape.Count(); i > 0; i--)
    {
        sszId->DelWCharsFromString((unsigned)(m_escape.Element(i - 1) - start), 1);
    }

    m_itr = m_currentItr;
    m_nextToken = LexAToken();
    return TRUE;
}

BOOL CLRTypeName::TypeNameParser::START()
{
    NextToken();
    NextToken();
    return AQN();
}

// FULLNAME ',' ASSEMSPEC
// FULLNAME
// /* empty */
BOOL CLRTypeName::TypeNameParser::AQN()
{
    IfFalseReturn(TokenIs(TypeNameAQN));

    if (TokenIs(TypeNameEnd))
    {
        return TRUE;
    }

    IfFalseReturn(FULLNAME());

    if (TokenIs(TypeNameComma))
    {
        NextToken();
        IfFalseReturn(ASSEMSPEC());
    }

    IfFalseReturn(TokenIs(TypeNameEnd));

    return TRUE;
}
Exemple #8
0
// *empty*
// ',' RANK
BOOL CLRTypeName::TypeNameParser::RANK(DWORD* pdwRank)
{
    if (!TokenIs(TypeNameRANK))
    {
        return TRUE;
    }

    NextToken();
    *pdwRank = *pdwRank + 1;
    IfFalseReturn(RANK(pdwRank));

    return TRUE;
}
Exemple #9
0
// '[' EAQN ']'
// FULLNAME
BOOL CLRTypeName::TypeNameParser::GENARG()
{
    IfFalseReturn(TokenIs(TypeNameGENARG));

    CLRTypeName* pEnclosingTypeName = m_pTypeName;
    m_pTypeName = m_pTypeName->AddGenericArgument();
    {
        if (TokenIs(TypeNameOpenSqBracket))
        {
            NextToken();
            IfFalseReturn(EAQN());

            IfFalseReturn(TokenIs(TypeNameCloseSqBracket));
            NextToken();
        }
        else
        {
            IfFalseReturn(FULLNAME());
        }
    }
    m_pTypeName = pEnclosingTypeName;

    return TRUE;
}
Exemple #10
0
void Expect(char *str)
{
  GetToken();
  if (TokenIs(str)) return;
  vcerr("error: %s expected, %s got", str, token);
}
Exemple #11
0
void CheckLibFunc()
{ int i;

  token_nvalue=0;
  token_type=0;

  if (TokenIs("if") || TokenIs("else") || TokenIs("for") ||
      TokenIs("while") || TokenIs("switch") || TokenIs("case") ||
      TokenIs("goto"))
  {
    token_type=RESERVED;
    return;
  }
  if (TokenIs("and"))
  {
     token_type=CONTROL;
     token[0]='&'; token[1]='&'; token[2]=0;
     return;
  }
  if (TokenIs("or"))
  {
     token_type=CONTROL;
     token[0]='|'; token[1]='|'; token[2]=0;
     return;
  }
  i=0;
  while (i<numhardfuncs)
  {
    if (!strcmp(hardfuncs[i], token)) break;
    i++;
  }
  if (i<numhardfuncs)
  {
    token_type=FUNCTION;
    token_subtype=op_BFUNC;
    funcidx=i;
  }
  i=0;
  while (i<numhardvar0)
  {
    if (!strcmp(hardvar0[i], token)) break;
    i++;
  }
  if (i<numhardvar0)
  {
    token_type=IDENTIFIER;
    varcategory=op_HVAR0;
    varidx=i;
  }
  i=0;
  while (i<numhardvar1)
  {
    if (!strcmp(hardvar1[i], token)) break;
    i++;
  }
  if (i<numhardvar1)
  {
    token_type=IDENTIFIER;
    varcategory=op_HVAR1;
    varidx=i;
  }

  i=0;
  while (i<numfuncs)
  {
    if (!strcmp(funcs[i].fname, token)) break;
    i++;
  }
  if (i<numfuncs)
  {
    token_type=FUNCTION;
    token_subtype=op_UFUNC;
    funcidx=i;
  }

  i=0;
  while (i<numvars)
  {
    if (!strcmp(vars[i].vname, token)) break;
    i++;
  }
  if (i<numvars)
  {
    token_type=IDENTIFIER;
    varidx=i;
    varcategory=op_UVAR;
    if (vars[varidx].arraylen>1) varcategory=op_UVARRAY;
  }
  i=0;
  while (i<funcs[c].numlocals)
  {
    if (!strcmp(larg[i], token)) break;
    i++;
  }
  if (i<funcs[c].numlocals)
  {
    token_type=IDENTIFIER;
    varidx=i;
    switch (funcs[c].argtype[varidx])
    {
      case INT: varcategory=op_LVAR; break;
      case STRING: varcategory=op_SLOCAL;
                   varidx=GetStringIdx(varidx);
                   break;
      default: vcerr("um.");
    }
  }
  i=0;
  while (i<numstr)
  {
    if (!strcmp(str[i].vname, token)) break;
    i++;
  }
  if (i<numstr)
  {
    token_type=IDENTIFIER;
    varidx=i;
    varcategory=op_STRING;
    if (str[i].arraylen>1) varcategory=op_SARRAY;
  }
}
Exemple #12
0
void CheckLibFunc()
{
	int		n;

	tok.value=0;
	tok.type=0;
	//token_nvalue=0;
	//token_type=0;

	if (TokenIs("if")	|| TokenIs("else")		|| TokenIs("for")
	|| TokenIs("while")	|| TokenIs("switch")	|| TokenIs("case")
	|| TokenIs("goto"))
	{
		tok.type=RESERVED;
		//token_type=RESERVED;
		return;
	}
	if (TokenIs("and")) {
		tok.type=CONTROL;
		tok.ident[0]='&';
		tok.ident[1]='&';
		tok.ident[2]='\0';
		//token_type=CONTROL;
		//token[0]='&'; token[1]='&'; token[2]=0;
		return;
	}
	if (TokenIs("or")) {
		tok.type=CONTROL;
		tok.ident[0]='|';
		tok.ident[1]='|';
		tok.ident[2]='\0';
		//token_type=CONTROL;
		//token[0]='|'; token[1]='|'; token[2]=0;
		return;
	}

	if (!hardfuncs_hash_ready) {
		init_hardfuncs_hash();
	}
	hardfunc_lookup::iterator iter=hardfuncs_hash.find(tok.ident);
	if (iter!=hardfuncs_hash.end()) {
		//printf("matched hardfunc: %s\n", tok.ident);
		hardfunc_t* hfunc=iter->second;
		tok.type=FUNCTION;
		tok.subtype=op_BFUNC;
		tok.index=hfunc->index;
		return;
	}

	//for (n=0; n<numhardfuncs; n++)
	//{
	//	if (!strcmp(hardfuncs[n], tok.ident)) //token))
	//	{
	//		//token_type=FUNCTION;
	//		//token_subtype=op_BFUNC;
	//		//funcidx=n;
	//		tok.type=FUNCTION;
	//		tok.subtype=op_BFUNC;
	//		tok.index=n;
	//		return;
	//	}
	//}

	if (!hardvar0_hash_ready) {
		init_hardvar0_hash();
	}
	hardvar0_lookup::iterator h0iter=hardvar0_hash.find(tok.ident);
	if (h0iter!=hardvar0_hash.end()) {
		//printf("matched hardvar0: %s\n", tok.ident);
		tok.type=IDENTIFIER;
		tok.subtype=op_HVAR0;
		tok.index=h0iter->second;
		return;
	}

	//for (n=0; n<numhardvar0; n++)
	//{
	//	if (!strcmp(hardvar0[n], tok.ident)) //token))
	//	{
	//		//token_type=IDENTIFIER;
	//		//varcategory=op_HVAR0;
	//		//varidx=n;
	//		tok.type=IDENTIFIER;
	//		tok.subtype=op_HVAR0;
	//		tok.index=n;
	//		return;
	//	}
	//}

	if (!hardvar1_hash_ready) {
		init_hardvar1_hash();
	}
	hardvar1_lookup::iterator h1iter=hardvar1_hash.find(tok.ident);
	if (h1iter!=hardvar1_hash.end()) {
		//printf("matched hardvar1: %s\n", tok.ident);
		tok.type=IDENTIFIER;
		tok.subtype=op_HVAR1;
		tok.index=h1iter->second;
		return;
	}

	//for (n=0; n<numhardvar1; n++)
	//{
	//	if (!strcmp(hardvar1[n], tok.ident)) //token))
	//	{
	//		//token_type=IDENTIFIER;
	//		//varcategory=op_HVAR1;
	//		//varidx=n;
	//		tok.type=IDENTIFIER;
	//		tok.subtype=op_HVAR1;
	//		tok.index=n;
	//		return;
	//	}
	//}

	if (functionlist_array.size())//number_nodes())
	{
		find_fun=0;
		function_lookup::iterator iter=functionlist.find(tok.ident);
		if (iter!=functionlist.end()) {
			tok.type=FUNCTION;
			tok.subtype=op_UFUNC;
			tok.index=iter->second->created_index;
			find_fun=iter->second;
			return;
		}
		//for (n=0; n<(int)functionlist.size(); n++) {
		//	function_t* f=functionlist[n];
		//	try {
		//		if (!strcmp(f->fname, tok.ident)) {
		//			tok.type=FUNCTION;
		//			tok.subtype=op_UFUNC;
		//			tok.index=n;
		//			find_fun=f;
		//			return;
		//		}
		//	} catch (...) {
		//		printf("exception during strcmp: f=%p, tok.ident=%s\n",f,tok.ident);
		//	}
		//}
		//do
		//{
		//	function_t* f=(function_t *)functionlist.current();
		//	if (!strcmp(f->fname, tok.ident)) //token))
		//	{
		//		tok.type=FUNCTION;
		//		tok.subtype=op_UFUNC;
		//		tok.index=n;
		//		//token_type=FUNCTION;
		//		//token_subtype=op_UFUNC;
		//		//funcidx=n;
		//		find_fun=f;
		//		return;
		//	}

		//	functionlist.go_next();
		//	n++;
		//} while (functionlist.current() != functionlist.head());
	}

	if (current_func)
	{
		for (n=0; n<current_func->numlocals; n++)
		{
			if (!strcmp(larg[n], tok.ident)) //token))
			{
				//token_type=IDENTIFIER;
				//varidx=0;
				tok.type=IDENTIFIER;
				tok.index=0;

				switch (current_func->argtype[n])
				{
				case INT:
					tok.subtype=op_LVAR;
					tok.index=GetVarIdx(n);
					//varcategory=op_LVAR;
					//varidx=GetVarIdx(n);
					break;
				case STRING:
					tok.subtype=op_SLOCAL;
					tok.index=GetStringIdx(n);
					//varcategory=op_SLOCAL;
					//varidx=GetStringIdx(n);
					break;

				default:
					vcerr("CheckLibFunc: invalid local type (weird): %d",
						current_func->argtype[n]);
				}
				return;
			}
		}
	}

	if (varlist_array.size())//number_nodes())
	{
		variable_lookup::iterator iter=varlist.find(tok.ident);
		if (iter!=varlist.end()) {
			tok.type=IDENTIFIER;
			tok.subtype=(iter->second->arraylen>1) ? op_UVARRAY : op_UVAR;
			tok.index=iter->second->created_index;
			find_var=iter->second;
			return;
		}

		//find_var=0;
		//for (n=0; n<(int)varlist.size(); n++) {
		//	variable_t* v=varlist[n];
		//	if (!strcmp(v->vname, tok.ident)) {
		//		tok.type=IDENTIFIER;
		//		tok.subtype=(v->arraylen>1) ? op_UVARRAY : op_UVAR;
		//		tok.index=n;
		//		find_var=v;
		//		return;
		//	}
		//}
		//varlist.go_head();
		//do
		//{
		//	variable_t* v=(variable_t *)varlist.current();
		//	if (!strcmp(v->vname, tok.ident)) //token))
		//	{
		//		tok.type=IDENTIFIER;
		//		tok.subtype=(v->arraylen>1) ? op_UVARRAY : op_UVAR;
		//		tok.index=n;
		//		//token_type=IDENTIFIER;
		//		//varcategory=(v->arraylen>1) ? op_UVARRAY : op_UVAR;
		//		//varidx=n;
		//		find_var=v;
		//		return;
		//	}
		//	varlist.go_next();
		//	n++;
		//} while (varlist.current() != varlist.head());
	}

 	if (strlist.size())//number_nodes())
	{
		find_str=0;
		string_lookup::iterator iter=strlist.find(tok.ident);
		if (iter!=strlist.end()) {
			tok.type=IDENTIFIER;
			tok.subtype=(iter->second->arraylen>1) ? op_SARRAY : op_STRING;
			tok.index=iter->second->created_index;
			find_str=iter->second;
			return;
		}

		//for (n=0; n<(int)strlist.size(); n++) {
		//	string_sym* s=strlist[n];
		//	if (!strcmp(s->vname, tok.ident)) {
		//		tok.type=IDENTIFIER;
		//		tok.subtype=(s->arraylen>1) ? op_SARRAY : op_STRING;
		//		tok.index=n;
		//		find_str=s;
		//		return;
		//	}
		//}
		//strlist.go_head();
		//do
		//{
		//	string_t* s=(string_t *)strlist.current();
		//	if (!strcmp(s->vname, tok.ident)) //token))
		//	{
		//		tok.type=IDENTIFIER;
		//		tok.subtype=(s->arraylen>1) ? op_SARRAY : op_STRING;
		//		tok.index=n;
		//		//token_type=IDENTIFIER;
		//		//varcategory=(s->arraylen>1) ? op_SARRAY : op_STRING;
		//		//varidx=n;
		//		find_str=s;
		//		return;
		//	}
		//	strlist.go_next();
		//	n++;
		//} while (strlist.current() != strlist.head());
	}
}