bastien/sl-compiler
1
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Add sources

Browse Source
This commit is contained in:
Bastien
2018-06-05 22:30:22 +02:00
parent e28912dc5e
commit 9b56ec979d
143 changed files with 8636 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
test/CMakeLists.txt Normal file
View File

@@ -0,0 +1,7 @@
cmake_minimum_required(VERSION 2.8)
include_directories(../src)
add_executable(sl_compiler compiler.cpp)
target_link_libraries(sl_compiler SL++)

40
test/compiler.cpp Normal file
View File

@@ -0,0 +1,40 @@
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include "Parser.h"
#include "Generator.h"
int main(int argc, char ** argv)
{
if (2 != argc)
{
printf("Usage: ./compiler <shader>\n");
return(1);
}
FILE * f = fopen(argv[1], "r");
// obtain file size
fseek(f , 0 , SEEK_END);
long lSize = ftell(f);
rewind(f);
char * source = (char *)malloc(sizeof(char)*lSize);
size_t result = fread(source, sizeof(char), lSize, f);
assert(result == sizeof(char)*lSize);
fclose(f);
Parser p(source);
p.buildAST();
//Generator::scheme::print_ast(p.getAST());
Generator::GLSL::print_ast(p.getAST());
return(0);
}

341
test/compiler_v1.cpp Normal file
View File

@@ -0,0 +1,341 @@
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include "Parser.h"
#include "AST/Function.h"
#include "AST/Namespace.h"
#include "AST/Structure.h"
static unsigned int count = 0;
void print_dot(const char * label)
{
printf("I_%u [label=\"%s\"] ;\n", count++, label);
}
void print_dot(int n)
{
printf("I_%u [label=\"%d\"] ;\n", count++, n);
}
void print_dot(unsigned int n)
{
printf("I_%u [label=\"%u\"] ;\n", count++, n);
}
void print_dot(long n)
{
printf("I_%u [label=\"%ld\"] ;\n", count++, n);
}
void print_dot(unsigned long n)
{
printf("I_%u [label=\"%lu\"] ;\n", count++, n);
}
void print_dot(float n)
{
printf("I_%u [label=\"%f\"] ;\n", count++, n);
}
void print_dot(double n)
{
printf("I_%u [label=\"%f\"] ;\n", count++, n);
}
void print_identifier(SL::Identifier * pNode)
{
print_dot(pNode->getValue());
}
void print_number(SL::Number * pNode)
{
switch(pNode->getFormat())
{
case SL::Number::INT:
{
print_dot(pNode->getValueAsInt());
}
break;
case SL::Number::UINT:
{
print_dot(pNode->getValueAsUInt());
}
break;
case SL::Number::LONG:
{
print_dot(pNode->getValueAsLong());
}
break;
case SL::Number::ULONG:
{
print_dot(pNode->getValueAsULong());
}
break;
case SL::Number::FLOAT:
{
print_dot(pNode->getValueAsFloat());
}
break;
case SL::Number::DOUBLE:
{
print_dot(pNode->getValueAsDouble());
}
break;
}
}
void print_keyword(SL::Keyword * pNode)
{
switch(pNode->getKeyword())
{
case SL::Keyword::NAMESPACE:
{
print_dot("namespace");
}
break;
case SL::Keyword::CLASS:
{
print_dot("class");
}
break;
case SL::Keyword::STRUCT:
{
print_dot("struct");
}
break;
case SL::Keyword::ENUM:
{
print_dot("enum");
}
break;
case SL::Keyword::IF:
{
print_dot("if");
}
break;
case SL::Keyword::FOR:
{
print_dot("for");
}
break;
case SL::Keyword::WHILE:
{
print_dot("while");
}
break;
case SL::Keyword::DO:
{
print_dot("do");
}
break;
}
}
void print_operator(SL::Operator * pNode)
{
switch(pNode->getOperator())
{
case SL::Operator::PLUS:
{
print_dot("+");
}
break;
case SL::Operator::MINUS:
{
print_dot("-");
}
break;
case SL::Operator::MUL:
{
print_dot("*");
}
break;
case SL::Operator::DIV:
{
print_dot("/");
}
break;
case SL::Operator::MODULO:
{
print_dot("%");
}
break;
case SL::Operator::INCREMENT:
{
print_dot("++");
}
break;
case SL::Operator::EQUAL:
{
print_dot("=");
}
break;
case SL::Operator::DECREMENT:
{
print_dot("--");
}
break;
case SL::Operator::EQ:
{
print_dot("==");
}
break;
case SL::Operator::NEQ:
{
print_dot("!=");
}
break;
}
}
void print_recurse(const AST::Node * pCurrentNode)
{
if (nullptr == pCurrentNode) return; // should be an assert !!!
switch (pCurrentNode->getType())
{
case AST::Node::NAMESPACE:
{
printf(" (ns %s", static_cast<const AST::Namespace *>(pCurrentNode)->getName().c_str());
}
break;
case AST::Node::STRUCTURE:
{
printf(" (struct %s", static_cast<const AST::Structure *>(pCurrentNode)->getName().c_str());
}
break;
case AST::Node::FUNCTION:
{
printf(" (fn %s %s", static_cast<const AST::Function *>(pCurrentNode)->getReturnType().c_str(), static_cast<const AST::Function *>(pCurrentNode)->getName().c_str());
}
break;
}
for (const AST::Node * pNode : pCurrentNode->getNodes())
{
print_recurse(pNode);
}
printf(")");
}
void print_ast(const std::vector<const AST::Node *> & aNodes)
{
for (const AST::Node * pNode : aNodes)
{
print_recurse(pNode);
}
printf("\n");
}
int main(int argc, char ** argv)
{
if (2 != argc)
{
printf("Usage: ./compiler <shader>\n");
return(1);
}
FILE * f = fopen(argv[1], "r");
// obtain file size
fseek(f , 0 , SEEK_END);
long lSize = ftell(f);
rewind(f);
char * source = (char *)malloc(sizeof(char)*lSize);
size_t result = fread(source, sizeof(char), lSize, f);
assert(result == sizeof(char)*lSize);
fclose(f);
Parser p(source);
p.buildAST();
print_ast(p.getAST());
#if 0
printf("graph NS_GLOBAL {\n");
for (SL::Token * pNode : p.getAST_v1())
{
assert(nullptr != pNode);
switch(pNode->getType())
{
case SL::Token::NUMBER:
{
print_number(static_cast<SL::Number*>(pNode));
}
break;
case SL::Token::IDENTIFIER:
{
print_identifier(static_cast<SL::Identifier*>(pNode));
}
break;
case SL::Token::KEYWORD:
{
print_keyword(static_cast<SL::Keyword*>(pNode));
}
break;
case SL::Token::OPERATOR:
{
print_operator(static_cast<SL::Operator*>(pNode));
}
break;
case SL::Token::SEPARATOR:
{
print_dot("SEPARATOR ");
}
break;
case SL::Token::ENDMARK:
{
//assert(false);
}
break;
default:
{
assert(false);
}
}
}
printf("} \n");
#endif
return(0);
}