#include "verilog_frontend.h"
#include "kernel/log.h"
#include <stdarg.h>
#include <stdio.h>
#include <string.h>

Include dependency graph for preproc.cc:

Functions
static void	return_char (char ch)

static void	insert_input (std::string str)

static char	next_char ()

static std::string	skip_spaces ()

static std::string	next_token (bool pass_newline=false)

static void	input_file (std::istream &f, std::string filename)

std::string	frontend_verilog_preproc (std::istream &f, std::string filename, const std::map< std::string, std::string > pre_defines_map, const std::list< std::string > include_dirs)

Variables
static YOSYS_NAMESPACE_BEGIN std::list< std::string >	output_code

static std::list< std::string >	input_buffer

static size_t	input_buffer_charp

Function Documentation

std::string frontend_verilog_preproc	(	std::istream &	f,
		std::string	filename,
		const std::map< std::string, std::string >	pre_defines_map,
		const std::list< std::string >	include_dirs
	)

Definition at line 212 of file preproc.cc.

 {
     std::set<std::string> defines_with_args;
     std::map<std::string, std::string> defines_map(pre_defines_map);
     int ifdef_fail_level = 0;
     bool in_elseif = false;
 
     output_code.clear();
     input_buffer.clear();
     input_buffer_charp = 0;
 
     input_file(f, filename);
     defines_map["__YOSYS__"] = "1";
 
     while (!input_buffer.empty())
     {
         std::string tok = next_token();
         // printf("token: >>%s<<\n", tok != "\n" ? tok.c_str() : "NEWLINE");
 
         if (tok == "`endif") {
             if (ifdef_fail_level > 0)
                 ifdef_fail_level--;
             if (ifdef_fail_level == 0)
                 in_elseif = false;
             continue;
         }
 
         if (tok == "`else") {
             if (ifdef_fail_level == 0)
                 ifdef_fail_level = 1;
             else if (ifdef_fail_level == 1 && !in_elseif)
                 ifdef_fail_level = 0;
             continue;
         }
 
         if (tok == "`elsif") {
             skip_spaces();
             std::string name = next_token(true);
             if (ifdef_fail_level == 0)
                 ifdef_fail_level = 1, in_elseif = true;
             else if (ifdef_fail_level == 1 && defines_map.count(name) != 0)
                 ifdef_fail_level = 0, in_elseif = true;
             continue;
         }
 
         if (tok == "`ifdef") {
             skip_spaces();
             std::string name = next_token(true);
             if (ifdef_fail_level > 0 || defines_map.count(name) == 0)
                 ifdef_fail_level++;
             continue;
         }
 
         if (tok == "`ifndef") {
             skip_spaces();
             std::string name = next_token(true);
             if (ifdef_fail_level > 0 || defines_map.count(name) != 0)
                 ifdef_fail_level++;
             continue;
         }
 
         if (ifdef_fail_level > 0) {
             if (tok == "\n")
                 output_code.push_back(tok);
             continue;
         }
 
         if (tok == "`include") {
             skip_spaces();
             std::string fn = next_token(true);
             while (1) {
                 size_t pos = fn.find('"');
                 if (pos == std::string::npos)
                     break;
                 if (pos == 0)
                     fn = fn.substr(1);
                 else
                     fn = fn.substr(0, pos) + fn.substr(pos+1);
             }
             std::ifstream ff;
             ff.clear();
             ff.open(fn.c_str());
             if (ff.fail() && fn.size() > 0 && fn[0] != '/' && filename.find('/') != std::string::npos) {
                 // if the include file was not found, it is not given with an absolute path, and the
                 // currently read file is given with a path, then try again relative to its directory
                 ff.clear();
                 ff.open(filename.substr(0, filename.rfind('/')+1) + fn);
             }
             if (ff.fail() && fn.size() > 0 && fn[0] != '/') {
                 // if the include file was not found and it is not given with an absolute path, then
                 // search it in the include path
                 for (auto incdir : include_dirs) {
                     ff.clear();
                     ff.open(incdir + '/' + fn);
                     if (!ff.fail()) break;
                 }
             }
             if (ff.fail())
                 output_code.push_back("`file_notfound " + fn);
             else
                 input_file(ff, fn);
             continue;
         }
 
         if (tok == "`define") {
             std::string name, value;
             std::map<std::string, int> args;
             skip_spaces();
             name = next_token(true);
             bool here_doc_mode = false;
             int newline_count = 0;
             int state = 0;
             if (skip_spaces() != "")
                 state = 3;
             while (!tok.empty()) {
                 tok = next_token();
                 if (tok == "\"\"\"") {
                     here_doc_mode = !here_doc_mode;
                     continue;
                 }
                 if (state == 0 && tok == "(") {
                     state = 1;
                     skip_spaces();
                 } else
                 if (state == 1) {
                     if (tok == ")")
                         state = 2;
                     else if (tok != ",") {
                         int arg_idx = args.size()+1;
                         args[tok] = arg_idx;
                     }
                     skip_spaces();
                 } else {
                     if (state != 2)
                         state = 3;
                     if (tok == "\n") {
                         if (here_doc_mode) {
                             value += " ";
                             newline_count++;
                         } else {
                             return_char('\n');
                             break;
                         }
                     } else
                     if (tok == "\\") {
                         char ch = next_char();
                         if (ch == '\n') {
                             value += " ";
                             newline_count++;
                         } else {
                             value += std::string("\\");
                             return_char(ch);
                         }
                     } else
                     if (args.count(tok) > 0)
                         value += stringf("`macro_%s_arg%d", name.c_str(), args.at(tok));
                     else
                         value += tok;
                 }
             }
             while (newline_count-- > 0)
                 return_char('\n');
             // printf("define: >>%s<< -> >>%s<<\n", name.c_str(), value.c_str());
             defines_map[name] = value;
             if (state == 2)
                 defines_with_args.insert(name);
             else
                 defines_with_args.erase(name);
             continue;
         }
 
         if (tok == "`undef") {
             std::string name;
             skip_spaces();
             name = next_token(true);
             // printf("undef: >>%s<<\n", name.c_str());
             defines_map.erase(name);
             defines_with_args.erase(name);
             continue;
         }
 
         if (tok == "`timescale") {
             skip_spaces();
             while (!tok.empty() && tok != "\n")
                 tok = next_token(true);
             if (tok == "\n")
                 return_char('\n');
             continue;
         }
 
         if (tok.size() > 1 && tok[0] == '`' && defines_map.count(tok.substr(1)) > 0) {
             std::string name = tok.substr(1);
             // printf("expand: >>%s<< -> >>%s<<\n", name.c_str(), defines_map[name].c_str());
             std::string skipped_spaces = skip_spaces();
             tok = next_token(false);
             if (tok == "(" && defines_with_args.count(name) > 0) {
                 int level = 1;
                 std::vector<std::string> args;
                 args.push_back(std::string());
                 while (1)
                 {
                     tok = next_token(true);
                     if (tok == ")" || tok == "}" || tok == "]")
                         level--;
                     if (level == 0)
                         break;
                     if (level == 1 && tok == ",")
                         args.push_back(std::string());
                     else
                         args.back() += tok;
                     if (tok == "(" || tok == "{" || tok == "[")
                         level++;
                 }
                 for (int i = 0; i < GetSize(args); i++)
                     defines_map[stringf("macro_%s_arg%d", name.c_str(), i+1)] = args[i];
             } else {
                 insert_input(tok);
                 insert_input(skipped_spaces);
             }
             insert_input(defines_map[name]);
             continue;
         }
 
         output_code.push_back(tok);
     }
 
     std::string output;
     for (auto &str : output_code)
         output += str;
 
     output_code.clear();
     input_buffer.clear();
     input_buffer_charp = 0;
 
     return output;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void input_file	(	std::istream &	f,
		std::string	filename
	)

static

Definition at line 196 of file preproc.cc.

 {
     char buffer[513];
     int rc;
 
     insert_input("");
     auto it = input_buffer.begin();
 
     input_buffer.insert(it, "`file_push " + filename + "\n");
     while ((rc = readsome(f, buffer, sizeof(buffer)-1)) > 0) {
         buffer[rc] = 0;
         input_buffer.insert(it, buffer);
     }
     input_buffer.insert(it, "\n`file_pop\n");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void insert_input ( std::string str )

static

Definition at line 55 of file preproc.cc.

 {
     if (input_buffer_charp != 0) {
         input_buffer.front() = input_buffer.front().substr(input_buffer_charp);
         input_buffer_charp = 0;
     }
     input_buffer.push_front(str);
 }

Here is the caller graph for this function:

static char next_char ( )

static

Definition at line 64 of file preproc.cc.

 {
     if (input_buffer.empty())
         return 0;
 
     log_assert(input_buffer_charp <= input_buffer.front().size());
     if (input_buffer_charp == input_buffer.front().size()) {
         input_buffer_charp = 0;
         input_buffer.pop_front();
         return next_char();
     }
 
     char ch = input_buffer.front()[input_buffer_charp++];
     return ch == '\r' ? next_char() : ch;
 }

Here is the caller graph for this function:

static std::string next_token ( bool pass_newline = false )

static

Definition at line 96 of file preproc.cc.

 {
     std::string token;
 
     char ch = next_char();
     if (ch == 0)
         return token;
 
     token += ch;
     if (ch == '\n') {
         if (pass_newline) {
             output_code.push_back(token);
             return "";
         }
         return token;
     }
     
     if (ch == ' ' || ch == '\t')
     {
         while ((ch = next_char()) != 0) {
             if (ch != ' ' && ch != '\t') {
                 return_char(ch);
                 break;
             }
             token += ch;
         }
     }
     else if (ch == '"')
     {
         while ((ch = next_char()) != 0) {
             token += ch;
             if (ch == '"')
                 break;
             if (ch == '\\') {
                 if ((ch = next_char()) != 0)
                     token += ch;
             }
         }
         if (token == "\"\"" && (ch = next_char()) != 0) {
             if (ch == '"')
                 token += ch;
             else
                 return_char(ch);
         }
     }
     else if (ch == '/')
     {
         if ((ch = next_char()) != 0) {
             if (ch == '/') {
                 token += '*';
                 char last_ch = 0;
                 while ((ch = next_char()) != 0) {
                     if (ch == '\n') {
                         return_char(ch);
                         break;
                     }
                     if (last_ch != '*' || ch != '/') {
                         token += ch;
                         last_ch = ch;
                     }
                 }
                 token += " */";
             }
             else if (ch == '*') {
                 token += '*';
                 int newline_count = 0;
                 char last_ch = 0;
                 while ((ch = next_char()) != 0) {
                     if (ch == '\n') {
                         newline_count++;
                         token += ' ';
                     } else
                         token += ch;
                     if (last_ch == '*' && ch == '/')
                         break;
                     last_ch = ch;
                 }
                 while (newline_count-- > 0)
                     return_char('\n');
             }
             else
                 return_char(ch);
         }
     }
     else
     {
         const char *ok = "abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ$0123456789";
         if (ch == '`' || strchr(ok, ch) != NULL)
             while ((ch = next_char()) != 0) {
                 if (strchr(ok, ch) == NULL) {
                     return_char(ch);
                     break;
                 }
                 token += ch;
             }
     }
 
     return token;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void return_char ( char ch )

static

Definition at line 47 of file preproc.cc.

 {
     if (input_buffer_charp == 0)
         input_buffer.push_front(std::string() + ch);
     else
         input_buffer.front()[--input_buffer_charp] = ch;
 }

Here is the caller graph for this function:

static std::string skip_spaces ( )

static

Definition at line 80 of file preproc.cc.

 {
     std::string spaces;
     while (1) {
         char ch = next_char();
         if (ch == 0)
             break;
         if (ch != ' ' && ch != '\t') {
             return_char(ch);
             break;
         }
         spaces += ch;
     }
     return spaces;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

std::list<std::string> input_buffer

static

Definition at line 44 of file preproc.cc.

size_t input_buffer_charp

static

Definition at line 45 of file preproc.cc.

YOSYS_NAMESPACE_BEGIN std::list<std::string> output_code

static

Definition at line 43 of file preproc.cc.

Functions

Variables

Function Documentation

Variable Documentation