396 lines
8.3 KiB
C++
396 lines
8.3 KiB
C++
#include "brb.h"
|
|
#include "asmrigs/tokenparser.h"
|
|
#include "tier0/commandline.h"
|
|
#include "tier2/ifilesystem.h"
|
|
|
|
IBGenerator *g_pGenerator;
|
|
|
|
class CBGenerator: public IBGenerator
|
|
{
|
|
public:
|
|
virtual void AddExternSymbol( const char *szName ) override;
|
|
virtual void DefineFunction( const char *szName ) override;
|
|
virtual CUtlString GetAssembly() override;
|
|
CUtlVector<CUtlString> m_externalSymbols;
|
|
CUtlString m_szAssembly;
|
|
};
|
|
EXPOSE_INTERFACE(CBGenerator, IBGenerator, B_GENERATOR_INTERFACE_VERSION);
|
|
|
|
void CBGenerator::AddExternSymbol( const char *szName )
|
|
{
|
|
m_externalSymbols.AppendTail(szName);
|
|
}
|
|
|
|
void CBGenerator::DefineFunction( const char *szName )
|
|
{
|
|
m_szAssembly.AppendTail(CUtlString("public %s\n", szName));
|
|
m_szAssembly.AppendTail(CUtlString("%s:\n", szName));
|
|
}
|
|
|
|
CUtlString CBGenerator::GetAssembly()
|
|
{
|
|
return m_szAssembly;
|
|
}
|
|
|
|
void CompileErrorExpectedToken( Token_t *pToken, const char *szToken )
|
|
{
|
|
if (pToken->m_bIsQuoted)
|
|
V_printf("%d:%d: expected %s but got string literal\n", pToken->m_iLine, pToken->m_iCharacter, szToken);
|
|
else
|
|
V_printf("%d:%d: expected %s but got %s\n", pToken->m_iLine, pToken->m_iCharacter, szToken, pToken->m_szValue.GetString());
|
|
exit(1);
|
|
}
|
|
|
|
void CompileErrorUnexpectedToken( Token_t *pToken )
|
|
{
|
|
if (pToken->m_bIsQuoted)
|
|
V_printf("%d:%d: unexpected string literal\n", pToken->m_iLine, pToken->m_iCharacter );
|
|
else
|
|
V_printf("%d:%d: unexpected %s\n", pToken->m_iLine, pToken->m_iCharacter, pToken->m_szValue.GetString());
|
|
exit(1);
|
|
}
|
|
void CompileErrorGotRValue( Token_t *pToken )
|
|
{
|
|
V_printf("%d:%d: got rvalue when expected lvalue\n", pToken->m_iLine, pToken->m_iCharacter );
|
|
exit(1);
|
|
}
|
|
|
|
enum EBValueType
|
|
{
|
|
EBVALUE_TYPE_UNKNOWN,
|
|
EBVALUE_TYPE_INT_LITERAL,
|
|
EBVALUE_TYPE_VARIABLE,
|
|
};
|
|
|
|
struct BValue_t
|
|
{
|
|
enum EBValueType m_eType;
|
|
int m_iLiteral;
|
|
const char *m_szVarName;
|
|
};
|
|
|
|
enum EBValueNodeOp
|
|
{
|
|
EBVALUE_OP_NOTHING,
|
|
EBVALUE_OP_VALUE,
|
|
EBVALUE_OP_READ_PTR,
|
|
EBVALUE_OP_GET_PTR,
|
|
EBVALUE_OP_ADD,
|
|
EBVALUE_OP_SUB,
|
|
EBVALUE_OP_MUL,
|
|
EBVALUE_OP_DIV,
|
|
EBVALUE_OP_PARENTHESIS,
|
|
EBVALUE_OP_NEG,
|
|
EBVALUE_OP_NOT,
|
|
};
|
|
|
|
struct Node_t
|
|
{
|
|
BValue_t m_value;
|
|
struct Node_t *m_pLeftValue;
|
|
struct Node_t *m_pRightValue;
|
|
EBValueNodeOp m_eOp;
|
|
};
|
|
|
|
struct ScopeVariable_t
|
|
{
|
|
const char *szName;
|
|
};
|
|
|
|
|
|
BValue_t ParseVar( CTokenParser *pParser )
|
|
{
|
|
const char *szToken = pParser->PeekToken();
|
|
|
|
if (V_isdigit(szToken[0]))
|
|
{
|
|
pParser->Continue();
|
|
return {EBVALUE_TYPE_INT_LITERAL, atoi(szToken)};
|
|
}
|
|
pParser->Continue();
|
|
return {EBVALUE_TYPE_VARIABLE, 0, szToken};
|
|
};
|
|
Node_t *ParseExpr( CTokenParser *pParser );
|
|
void ParseRValue( CTokenParser *pParser );
|
|
Node_t *ParsePrimary( CTokenParser *pParser )
|
|
{
|
|
Node_t *pNode;
|
|
if (pParser->IsToken("("))
|
|
{
|
|
pParser->Continue();
|
|
pNode = ParseExpr(pParser);
|
|
if (!pParser->IsToken(")"))
|
|
CompileErrorExpectedToken(pParser->m_pCurrentToken, ")");
|
|
pParser->Continue();
|
|
goto lvalue;
|
|
}
|
|
pNode = new Node_t();
|
|
pNode->m_eOp = EBVALUE_OP_VALUE;
|
|
pNode->m_value = ParseVar( pParser );
|
|
lvalue:
|
|
if (pParser->IsToken("="))
|
|
{
|
|
if (pNode->m_eOp == EBVALUE_OP_VALUE)
|
|
{
|
|
if ( pNode->m_value.m_eType == EBVALUE_TYPE_VARIABLE )
|
|
goto confirmedlvalue;
|
|
};
|
|
CompileErrorGotRValue(pParser->m_pCurrentToken);
|
|
confirmedlvalue:
|
|
pParser->Continue();
|
|
ParseRValue(pParser);
|
|
};
|
|
|
|
return pNode;
|
|
}
|
|
Node_t *ParseUnary( CTokenParser *pParser )
|
|
{
|
|
return ParsePrimary(pParser);
|
|
}
|
|
Node_t *ParseTerm( CTokenParser *pParser )
|
|
{
|
|
Node_t *pNode;
|
|
Node_t *pNewNode;
|
|
|
|
EBValueNodeOp eOp = EBVALUE_OP_NOTHING;
|
|
pNode = new Node_t();
|
|
for (;;)
|
|
{
|
|
if (pParser->IsToken("*"))
|
|
{
|
|
pParser->Continue();
|
|
eOp = EBVALUE_OP_MUL;
|
|
}
|
|
else if (pParser->IsToken("/"))
|
|
{
|
|
pParser->Continue();
|
|
eOp = EBVALUE_OP_DIV;
|
|
}
|
|
else
|
|
{
|
|
pNode->m_eOp = eOp;
|
|
if (pNode->m_pLeftValue == NULL)
|
|
pNode->m_pLeftValue = ParseUnary(pParser);
|
|
else
|
|
{
|
|
if (eOp == EBVALUE_OP_NOTHING)
|
|
break;
|
|
eOp = EBVALUE_OP_NOTHING;
|
|
pNode->m_pRightValue = ParseUnary(pParser);
|
|
pNewNode = new Node_t();
|
|
pNewNode->m_pLeftValue = pNode;
|
|
pNode = pNewNode;
|
|
}
|
|
}
|
|
}
|
|
if (pNode->m_pRightValue == NULL)
|
|
{
|
|
pNewNode = pNode->m_pLeftValue;
|
|
delete pNode;
|
|
return pNewNode;
|
|
}
|
|
return pNode;
|
|
}
|
|
|
|
Node_t *ParseExpr( CTokenParser *pParser )
|
|
{
|
|
Node_t *pNode;
|
|
Node_t *pNewNode;
|
|
|
|
EBValueNodeOp eOp = EBVALUE_OP_NOTHING;
|
|
pNode = new Node_t();
|
|
for (;;)
|
|
{
|
|
if (pParser->IsToken("+"))
|
|
{
|
|
pParser->Continue();
|
|
eOp = EBVALUE_OP_ADD;
|
|
}
|
|
else if (pParser->IsToken("-"))
|
|
{
|
|
pParser->Continue();
|
|
eOp = EBVALUE_OP_SUB;
|
|
}
|
|
else
|
|
{
|
|
pNode->m_eOp = eOp;
|
|
if (pNode->m_pLeftValue == NULL)
|
|
pNode->m_pLeftValue = ParseTerm(pParser);
|
|
else
|
|
{
|
|
if (eOp == EBVALUE_OP_NOTHING)
|
|
break;
|
|
eOp = EBVALUE_OP_NOTHING;
|
|
pNode->m_pRightValue = ParseTerm(pParser);
|
|
pNewNode = new Node_t();
|
|
pNewNode->m_pLeftValue = pNode;
|
|
pNode = pNewNode;
|
|
}
|
|
}
|
|
}
|
|
if (pNode->m_pRightValue == NULL)
|
|
{
|
|
pNewNode = pNode->m_pLeftValue;
|
|
delete pNode;
|
|
return pNewNode;
|
|
}
|
|
return pNode;
|
|
}
|
|
|
|
void PrintExpr( Node_t *pNode )
|
|
{
|
|
if ( pNode->m_eOp == EBVALUE_OP_VALUE )
|
|
{
|
|
switch ( pNode->m_value.m_eType )
|
|
{
|
|
case EBVALUE_TYPE_INT_LITERAL:
|
|
V_printf("%i\n", pNode->m_value.m_iLiteral);
|
|
break;
|
|
case EBVALUE_TYPE_VARIABLE:
|
|
V_printf("%s\n", pNode->m_value.m_szVarName);
|
|
break;
|
|
|
|
}
|
|
} else {
|
|
if (pNode->m_pLeftValue)
|
|
PrintExpr(pNode->m_pLeftValue);
|
|
if (pNode->m_pRightValue)
|
|
PrintExpr(pNode->m_pRightValue);
|
|
if (pNode->m_eOp == EBVALUE_OP_ADD)
|
|
V_printf("+\n");
|
|
if (pNode->m_eOp == EBVALUE_OP_SUB)
|
|
V_printf("-\n");
|
|
if (pNode->m_eOp == EBVALUE_OP_MUL)
|
|
V_printf("*\n");
|
|
if (pNode->m_eOp == EBVALUE_OP_DIV)
|
|
V_printf("/\n");
|
|
}
|
|
}
|
|
|
|
void ParseRValue( CTokenParser *pParser )
|
|
{
|
|
PrintExpr(ParseExpr( pParser ));
|
|
}
|
|
|
|
void ParseStatement( CTokenParser *pParser )
|
|
{
|
|
if (pParser->IsToken("return"))
|
|
{
|
|
pParser->Continue();
|
|
ParseRValue( pParser );
|
|
if (!pParser->IsToken(";"))
|
|
CompileErrorExpectedToken(pParser->m_pCurrentToken, ";");
|
|
V_printf(" ret\n");
|
|
pParser->Continue();
|
|
}
|
|
else if (pParser->IsToken("extrn"))
|
|
{
|
|
pParser->Continue();
|
|
for (;;)
|
|
{
|
|
const char *szName = pParser->PeekToken();
|
|
pParser->Continue();
|
|
if (pParser->IsToken(","))
|
|
{
|
|
pParser->Continue();
|
|
continue;
|
|
}
|
|
if (pParser->IsToken(";"))
|
|
{
|
|
pParser->Continue();
|
|
break;
|
|
}
|
|
CompileErrorUnexpectedToken(pParser->m_pCurrentToken);
|
|
};
|
|
}
|
|
else if (pParser->IsToken("auto"))
|
|
{
|
|
pParser->Continue();
|
|
for (;;)
|
|
{
|
|
const char *szName = pParser->PeekToken();
|
|
pParser->Continue();
|
|
if (pParser->IsToken(","))
|
|
{
|
|
pParser->Continue();
|
|
continue;
|
|
}
|
|
if (pParser->IsToken(";"))
|
|
{
|
|
pParser->Continue();
|
|
break;
|
|
}
|
|
CompileErrorUnexpectedToken(pParser->m_pCurrentToken);
|
|
};
|
|
}
|
|
else
|
|
{
|
|
ParseRValue(pParser);
|
|
if (!pParser->IsToken(";"))
|
|
CompileErrorExpectedToken(pParser->m_pCurrentToken, ";");
|
|
pParser->Continue();
|
|
};
|
|
|
|
}
|
|
|
|
void ParseGlobal( CTokenParser *pParser )
|
|
{
|
|
|
|
for (;;)
|
|
{
|
|
if (pParser->IsEOF())
|
|
break;
|
|
const char *szObjectName = pParser->PeekToken();
|
|
pParser->Continue();
|
|
|
|
if (pParser->IsToken("("))
|
|
{
|
|
pParser->Continue();
|
|
if (!pParser->IsToken(")"))
|
|
CompileErrorExpectedToken(pParser->m_pCurrentToken, ")");
|
|
pParser->Continue();
|
|
g_pGenerator->DefineFunction(szObjectName);
|
|
|
|
if (!pParser->IsToken("{"))
|
|
CompileErrorExpectedToken(pParser->m_pCurrentToken, "{");
|
|
pParser->Continue();
|
|
while (!pParser->IsToken("}"))
|
|
{
|
|
ParseStatement( pParser );
|
|
}
|
|
pParser->Continue();
|
|
}
|
|
else
|
|
{
|
|
CompileErrorExpectedToken(pParser->m_pCurrentToken, "(");
|
|
}
|
|
}
|
|
V_printf("%s\n", g_pGenerator->GetAssembly().GetString());
|
|
};
|
|
|
|
|
|
int main( int argc, char **argv )
|
|
{
|
|
CommandLine()->CreateCommandLine(argc, argv);
|
|
|
|
CreateInterfaceFn filesystemFactory = Sys_GetFactory("filesystem_std");
|
|
filesystem = (IFileSystem*)filesystemFactory(FILESYSTEM_INTERFACE_VERSION, NULL);
|
|
|
|
IFileHandle *pFile = filesystem->Open(argv[1], FILEMODE_READ);
|
|
const char *szFileContents = filesystem->ReadString(pFile);
|
|
filesystem->Close(pFile);
|
|
|
|
g_pGenerator = (IBGenerator*)CreateInterface(B_GENERATOR_INTERFACE_VERSION, NULL);
|
|
|
|
|
|
CUtlVector<Token_t> tokens = Tokenize(szFileContents);
|
|
CTokenParser parser;
|
|
parser.m_pTokens = tokens.GetData();
|
|
parser.m_pTokensEnd = tokens.GetData()+tokens.GetSize();
|
|
parser.m_pCurrentToken = tokens.GetData()-1;
|
|
parser.Continue();
|
|
ParseGlobal(&parser);
|
|
|
|
V_free((void*)szFileContents);
|
|
}
|