void L(void) {
if(lookahead == '('){
match('(');
if(lookahead == INT || lookahead == CHAR){
match(lookahead);
pointers();
match(')');
L();
printf("cast\n");
}
else{
expression();
match(')');
}
}
else{
M();
}
}
/*void translationunit(void){
globaldeclaration();
translationunit();
}*/
void globaldeclaration(void){
typespecifier();
pointers();
match(ID);
if(lookahead == '('){
match('(');
parameters();
match(')');
match('{');
declarations();
statements();
match('}');
}
else{
if(lookahead == '['){
match('[');
match(NUM);
match(']');
}
if(lookahead == ','){
declaratorlist();
}
match(';');
}
}
void pointers(void) {
if(lookahead == '*')
{
match('*');
pointers();
}
}
void declarator(void){
pointers();
match(ID);
if(lookahead == '['){
match('[');
match(NUM);
match(']');
}
}
bool Shader::compile() {
CORRADE_ASSERT(sources.size() > 1, "Shader::compile(): no files added", false);
/* Array of source string pointers and their lengths */
/** @todo Use `Containers::ArrayTuple` to avoid one allocation if it ever
gets to be implemented (we need properly aligned memory too) */
Containers::Array<const GLchar*> pointers(sources.size());
Containers::Array<GLint> sizes(sources.size());
for(std::size_t i = 0; i != sources.size(); ++i) {
pointers[i] = static_cast<const GLchar*>(sources[i].data());
sizes[i] = sources[i].size();
}
/* Create shader and set its source */
glShaderSource(_id, sources.size(), pointers, sizes);
/* Compile shader */
glCompileShader(_id);
/* Check compilation status */
GLint success, logLength;
glGetShaderiv(_id, GL_COMPILE_STATUS, &success);
glGetShaderiv(_id, GL_INFO_LOG_LENGTH, &logLength);
/* Error or warning message. The string is returned null-terminated, scrap
the \0 at the end afterwards */
std::string message(logLength, '\0');
if(message.size() > 1)
glGetShaderInfoLog(_id, message.size(), nullptr, &message[0]);
message.resize(std::max(logLength, 1)-1);
/* Show error log */
if(!success) {
Error out;
out.setFlag(Debug::NewLineAtTheEnd, false);
out.setFlag(Debug::SpaceAfterEachValue, false);
out << "Shader: " << shaderName(_type)
<< " shader failed to compile with the following message:\n"
<< message;
/* Or just message, if any */
} else if(!message.empty()) {
Error out;
out.setFlag(Debug::NewLineAtTheEnd, false);
out.setFlag(Debug::SpaceAfterEachValue, false);
out << "Shader: " << shaderName(_type)
<< " shader was successfully compiled with the following message:\n"
<< message;
}
return success;
}
bool isSpriteSheet(PG::STREAM::InByteFile& reader){
const unsigned int startPos = reader.pos();
spriteSheetHeader header;
reader.read((char*)&header, sizeof(spriteSheetHeader));
std::vector<unsigned int> pointers(4);
reader.read((char*)&pointers[0], 4*sizeof(unsigned int));
if(pointers[0] == 0 || pointers[1] == 0 || pointers[2] == 0 || pointers[3] == 0) return false;
if(pointers[3]+startPos >= reader.size()) return false;
return true;
}
void M(void) {
if (lookahead =='!') {
match('!');
M();
printf("not\n");
} else if (lookahead == '-') {
match('-');
M();
printf("neg\n");
} else if (lookahead == '&') {
match('&');
M();
printf("addr\n");
} else if (lookahead == '*') {
match('*');
M();
printf("dref\n");
} else if (lookahead == SZOF) {
match(SZOF);
match('(');
typespecifier();
pointers();
match(')');
printf("szof\n");
}
else {
N();
}
}
bool controller::export_ptr_list(const arguments &args_, std::string &) const {
std::ofstream pointers("sqf_pointers_declaration.hpp");
std::ofstream pointers_def("sqf_pointers_definitions.hpp");
std::ofstream assignments("sqf_assignments.hpp");
pointers << "//Exported Pointer Definitions For: " << args_.as_string(0) << "\n\n";
assignments << "//Exported Pointer Assignments For: " << args_.as_string(0) << "\n\n";
pointers << "\n// Unary Functions\n";
pointers_def << "\n// Unary Functions\n";
assignments << "\n// Unary Functions\n";
auto unary_list = loader::get().unary();
std::list<std::string> sorted_unary_list;
for (auto unary : unary_list) {
sorted_unary_list.push_back(unary.first);
}
sorted_unary_list.sort();
for (auto unary_entry : sorted_unary_list) {
std::string op_name = unary_entry;
std::regex name_test = std::regex("[a-z]+?.*");
if (std::regex_match(op_name, name_test)) {
for (auto op : unary_list[unary_entry]) {
std::string arg_types = op.op->arg_type.type_str();
std::transform(arg_types.begin(), arg_types.end(), arg_types.begin(), ::tolower);
std::string return_type = op.op->return_type.type_str();
std::transform(return_type.begin(), return_type.end(), return_type.begin(), ::tolower);
std::string first_arg_type = *op.op->arg_type.type().begin();
std::string pointer_name = "unary__" + op_name + "__" + arg_types + "__ret__" + return_type;
pointers_def << "unary_function __sqf::" << pointer_name << ";\n";
pointers << "static unary_function " << pointer_name << ";\n";
//__sqf::unary_random_scalar_raw = (unary_function)functions.get_unary_function_typed("random", "SCALAR");
assignments << "__sqf::" << pointer_name << " = " << "(unary_function)host::functions.get_unary_function_typed(\"" << op_name << "\"_sv, \"" << first_arg_type << "\"_sv);\n";
}
}
}
pointers << "\n// Binary Functions\n";
pointers_def << "\n// Binary Functions\n";
assignments << "\n// Binary Functions\n";
auto binary_list = loader::get().binary();
std::list<std::string> sorted_binary_list;
for (auto binary : binary_list) {
sorted_binary_list.push_back(binary.first);
};
sorted_binary_list.sort();
for (auto binary_entry : sorted_binary_list) {
std::string op_name = binary_entry;
std::regex name_test = std::regex("[a-z]+?.*");
if (std::regex_match(op_name, name_test)) {
for (auto op : binary_list[binary_entry]) {
std::string arg1_types = op.op->arg1_type.type_str();
std::transform(arg1_types.begin(), arg1_types.end(), arg1_types.begin(), ::tolower);
std::string arg2_types = op.op->arg2_type.type_str();
std::transform(arg2_types.begin(), arg2_types.end(), arg2_types.begin(), ::tolower);
std::string return_type = op.op->return_type.type_str();
std::transform(return_type.begin(), return_type.end(), return_type.begin(), ::tolower);
std::string first_arg1_type = *op.op->arg1_type.type().begin();
std::string first_arg2_type = *op.op->arg2_type.type().begin();
std::string pointer_name = "binary__" + op_name + "__" + arg1_types + "__" + arg2_types + "__ret__" + return_type;
pointers_def << "binary_function __sqf::" << pointer_name << ";\n";
pointers << "static binary_function " << pointer_name << ";\n";
assignments << "__sqf::" << pointer_name << " = " << "(binary_function)host::functions.get_binary_function_typed(\"" << op_name <<
"\"_sv, \"" << first_arg1_type << "\"_sv, \"" << first_arg2_type << "\"_sv);\n";
}
}
}
pointers << "\n// Nular Functions\n";
pointers_def << "\n// Nular Functions\n";
assignments << "\n// Nular Functions\n";
auto nular_list = loader::get().nular();
std::list<std::string> sorted_nular_list;
for (auto nular : nular_list) {
sorted_nular_list.push_back(nular.first);
};
sorted_nular_list.sort();
for (auto nular_entry : sorted_nular_list) {
std::string op_name = nular_entry;
std::regex name_test = std::regex("[a-z]+?.*");
if (std::regex_match(op_name, name_test)) {
for (auto op : nular_list[nular_entry]) {
std::string return_type = op.op->return_type.type_str();
std::transform(return_type.begin(), return_type.end(), return_type.begin(), ::tolower);
std::string pointer_name = "nular__" + op_name + "__ret__" + return_type;
pointers_def << "nular_function __sqf::" << pointer_name << ";\n";
pointers << "static nular_function " << pointer_name << ";\n";
//__sqf::unary_random_scalar_raw = (unary_function)functions.get_unary_function_typed("random", "SCALAR");
assignments << "__sqf::" << pointer_name << " = " << "(nular_function)host::functions.get_nular_function(\"" << op_name << "\"_sv);\n";
}
}
}
return true;
}
std::vector<Ptr> GetPointers() const {
std::vector<Ptr> pointers(Size());
RecurseForPointers(root, &pointers);
return pointers;
}
int main() {
pointers(); // else — links();
return 0;
}
