Squashed 'libs/EXTERNAL/libblifparse/' content from commit c4ba9de

git-subtree-dir: libs/EXTERNAL/libblifparse
git-subtree-split: c4ba9de9bff58e2bb7bb0bec012c7cb211212907

Author: kmurray

.gitignore

@@ -0,0 +1,9 @@
+build
+blifparse_test
+libblifparse.a
+obj/
+src/blif_lexer.gen.c
+src/blif_lexer.gen.h
+src/blif_parser.gen.c
+src/blif_parser.gen.h
+src/stack.hh

CMakeLists.txt

@@ -0,0 +1,52 @@
+cmake_minimum_required(VERSION 2.8.12)
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
+include(HeadersToIncludeDirs)
+
+project("libblifparse")
+
+if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR})
+    #Only set compiler settings if we are not a sub-project
+    set(WARN_FLAGS "-Wall -Wextra -Wpedantic -Wcast-qual -Wcast-align -Wshadow -Wformat=2 -Wlogical-op -Wmissing-declarations -Wmissing-include-dirs -Wredundant-decls -Wswitch-default -Wundef -Wunused-variable -Wdisabled-optimization -Wnoexcept -Woverloaded-virtual -Wctor-dtor-privacy -Wnon-virtual-dtor")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --std=c++11 ${WARN_FLAGS}") 
+    #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fsanitize=leak -fsanitize=undefined") 
+    set(FLEX_BISON_WARN_SUPPRESS_FLAGS "-Wno-switch-default -Wno-unused-parameter -Wno-missing-declarations")
+endif()
+
+#Flex and Bison are used to generate the parser
+find_package(BISON REQUIRED 3.0)
+find_package(FLEX REQUIRED)
+
+file(GLOB_RECURSE LIB_SOURCES src/blif*.cpp)
+file(GLOB_RECURSE LIB_HEADERS src/blif*.hpp)
+headers_to_include_dirs(LIB_HEADERS LIB_INCLUDE_DIRS)
+
+#Find the flex and bison input files
+file(GLOB_RECURSE LEXER_SOURCES src/blif*.l)
+file(GLOB_RECURSE PARSER_SOURCES src/blif*.y)
+
+#Make the flex and bison targets
+flex_target(BlifLexer ${LEXER_SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/blif_lexer.gen.cpp
+        COMPILE_FLAGS --header-file=${CMAKE_CURRENT_BINARY_DIR}/blif_lexer.gen.hpp)
+bison_target(BlifParser ${PARSER_SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/blif_parser.gen.cpp)
+add_flex_bison_dependency(BlifLexer BlifParser)
+
+#Suppress warnings in Flex/Bison generated files
+if(FLEX_BISON_WARN_SUPPRESS_FLAGS)
+    set_source_files_properties(${FLEX_BlifLexer_OUTPUTS} ${BISON_BlifParser_OUTPUT_SOURCE}
+                                PROPERTIES COMPILE_FLAGS ${FLEX_BISON_WARN_SUPPRESS_FLAGS})
+endif()
+
+#Create the library
+add_library(libblifparse STATIC
+             ${LIB_HEADERS}
+             ${LIB_SOURCES}
+             ${FLEX_BlifLexer_OUTPUTS} 
+             ${BISON_BlifParser_OUTPUT_SOURCE})
+target_include_directories(libblifparse PUBLIC ${LIB_INCLUDE_DIRS} ${CMAKE_CURRENT_BINARY_DIR})
+set_target_properties(libblifparse PROPERTIES PREFIX "") #Avoid extra 'lib' prefix
+
+#Create the test executable
+add_executable(blifparse_test src/main.cpp)
+target_link_libraries(blifparse_test libblifparse)
+
+install(TARGETS libblifparse blifparse_test DESTINATION bin)

LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Kevin E. Murray
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Makefile

@@ -0,0 +1,134 @@
+#Tools
+CXX = g++
+AR = ar
+LEXER_GEN = flex
+PARSER_GEN = bison
+
+#Whether this is a debug (symbols, no opt) or
+# release (no symbols, opt) build. May be 
+# inherited from build environment. Can
+# override by defining below.
+#
+# Can be 'debug' or 'release'
+#BUILD_TYPE = release
+
+# How verbose we want the make file
+#  0: print nothing
+#  1: print high-level message
+#  2: print high-level message + detailed command
+VERBOSITY = 1
+
+
+#Verbosity Configuration
+vecho_0 = true
+vecho_1 = echo
+vecho_2 = echo
+vecho = $(vecho_$(VERBOSITY))
+
+AT_0 := @
+AT_1 := @
+AT_2 := 
+AT = $(AT_$(VERBOSITY))
+
+#Final output files
+EXE=blifparse_test
+STATIC_LIB=libblifparse.a
+
+#Flags
+WARN_FLAGS = -Wall -Wpointer-arith -Wcast-qual -D__USE_FIXED_PROTOTYPES__ -ansi -pedantic -Wshadow -Wcast-align -D_POSIX_SOURCE -Wno-write-strings
+
+DEP_FLAGS = -MMD -MP
+
+DEBUG_FLAGS = -g -ggdb3 -g3 -O0 -fno-inline
+
+OPT_FLAGS = -O3
+
+ifneq (,$(findstring debug, $(BUILD_TYPE)))
+	DEBUG_OPT_FLAGS := $(DEBUG_FLAGS)
+else
+	DEBUG_OPT_FLAGS := $(OPT_FLAGS)
+endif
+
+INC_FLAGS = -I$(SRC_DIR) -I$(OBJ_DIR)
+
+CFLAGS = $(DEP_FLAGS) $(WARN_FLAGS) $(DEBUG_OPT_FLAGS) $(INC_FLAGS) -std=c++11 
+
+#Objects
+#.SUFFIXES: .o .c .y .l
+SRC_DIR = src
+OBJ_DIR = obj
+
+main_src = $(SRC_DIR)/main.cpp
+main_obj := $(patsubst %.cpp, %.o, $(main_src))
+main_obj := $(foreach obj, $(main_obj), $(patsubst $(SRC_DIR)/%.o, $(OBJ_DIR)/%.o, $(obj)))
+
+lib_src = $(wildcard $(SRC_DIR)/blif*.cpp)
+lib_obj := $(patsubst %.cpp, %.o, $(lib_src))
+lib_obj := $(foreach obj, $(lib_obj), $(patsubst $(SRC_DIR)/%.o, $(OBJ_DIR)/%.o, $(obj)))
+
+LEXER_SRC = $(SRC_DIR)/blif_lexer.l
+LEXER_GEN_SRC = $(SRC_DIR)/blif_lexer.gen.c
+LEXER_GEN_HDR = $(SRC_DIR)/blif_lexer.gen.h
+LEXER_GEN_OBJ := $(LEXER_GEN_SRC:.c=.o)
+LEXER_GEN_OBJ := $(foreach obj, $(LEXER_GEN_OBJ), $(patsubst $(SRC_DIR)/%.o, $(OBJ_DIR)/%.o, $(obj)))
+
+PARSER_SRC = $(SRC_DIR)/blif_parser.y
+PARSER_GEN_SRC = $(SRC_DIR)/blif_parser.gen.c
+PARSER_GEN_HDR = $(SRC_DIR)/blif_parser.gen.h
+PARSER_GEN_OBJ := $(PARSER_GEN_SRC:.c=.o)
+PARSER_GEN_OBJ := $(foreach obj, $(PARSER_GEN_OBJ), $(patsubst $(SRC_DIR)/%.o, $(OBJ_DIR)/%.o, $(obj)))
+
+OBJECTS_LIB = $(lib_obj) $(LEXER_GEN_OBJ) $(PARSER_GEN_OBJ)
+OBJECTS_EXE = $(main_obj) $(OBJECTS_LIB)
+
+#Dependancies
+DEP = $(OBJECTS_EXE:.o=.d)
+
+#Rules
+.PHONY: clean
+
+all: $(OBJ_DIR) $(STATIC_LIB) $(EXE) 
+
+-include $(DEP)
+
+$(EXE): $(OBJECTS_EXE)
+	@$(vecho) "Linking executable: $@"
+	$(AT) $(CXX) $(CFLAGS) -o $@ $(OBJECTS_EXE)
+
+$(LEXER_GEN_SRC) $(LEXER_GEN_HDR): $(LEXER_SRC)
+	@$(vecho) "Generating Lexer $(LEXER_SRC)..."
+	@#Avoid including "unistd.h" since it is unavailable on windows
+	$(AT) $(LEXER_GEN) --nounistd --header-file=$(LEXER_GEN_HDR) -o $(LEXER_GEN_SRC) $(LEXER_SRC)
+
+$(PARSER_GEN_SRC) $(PARSER_GEN_HDR): $(PARSER_SRC)
+	@$(vecho) "Generating Parser $(PARSER_SRC)..."
+	$(AT) $(PARSER_GEN) -d -o $(PARSER_GEN_SRC) $(PARSER_SRC)
+
+$(STATIC_LIB): $(OBJECTS_LIB)
+	@$(vecho) "Linking static library: $@"
+	$(AT) $(AR) rcs $@ $(OBJECTS_LIB)
+
+$(LEXER_GEN_OBJ): $(LEXER_GEN_SRC) $(PARSER_GEN_SRC)
+	@$(vecho) "Compiling Lexer $<..."
+	@#Suppress warning about unused function produced by flex
+	$(AT) $(CXX) $(CFLAGS) -Wno-unused-function -c $< -o $@
+
+$(PARSER_GEN_OBJ): $(PARSER_GEN_SRC)
+	@$(vecho) "Compiling Parser $<..."
+	$(AT) $(CXX) $(CFLAGS) -c $< -o $@
+
+$(OBJ_DIR)/%.o: $(SRC_DIR)/%.cpp $(LEXER_GEN_HDR) $(PARSER_GEN_HDR) $(OBJ_DIR)
+	@$(vecho) "Compiling Source $<..."
+	$(AT) $(CXX) $(CFLAGS) -c $< -o $@
+
+$(OBJ_DIR):
+	@ mkdir -p $@
+
+clean:
+	rm -f $(OBJECTS_EXE)
+	rm -f $(DEP)
+	rm -rf $(OBJ_DIR)
+	rm -f $(EXE)
+	rm -f $(STATIC_LIB)
+	rm -f $(LEXER_GEN_SRC) $(LEXER_GEN_HDR)
+	rm -f $(PARSER_GEN_SRC) $(PARSER_GEN_HDR) $(SRC_DIR)/stack.hh

README.md

@@ -0,0 +1,6 @@
+libblifparse
+----------------------------------
+
+This library provides a parser for a Berkely Logic Interchange Format (BLIF) files.
+See comments at the top of 'src/blifparse.hpp' for more detailed information and usage.
+

cmake/modules/HeadersToIncludeDirs.cmake

@@ -0,0 +1,16 @@
+function(headers_to_include_dirs header_file_list include_directory_list)
+    #Extract the directories for each header file
+    foreach(header ${${header_file_list}})
+        get_filename_component(incl_dir ${header} DIRECTORY)
+        list(APPEND dir_list ${incl_dir})
+    endforeach()
+
+    #Remove any duplicates
+    list(LENGTH "${dir_list}" length)
+    if(${length} GREATER 1) #Avoid error with zero-length lists
+        list(REMOVE_DUPLICATES ${dir_list})
+    endif()
+
+    #Set the second argument in the caller's scope
+    set(${include_directory_list} ${dir_list} PARENT_SCOPE)
+endfunction(headers_to_include_dirs)

doc/blif.pdf

@@ -0,0 +1,8 @@
+#include <cstdlib>
+#include <cstring>
+
+#include "blif_common.hpp"
+
+namespace blifparse {
+
+} //namespace

src/blif_common.cpp

@@ -0,0 +1,24 @@
+#ifndef BLIF_COMMON_HPP
+#define BLIF_COMMON_HPP
+
+#include "blifparse.hpp"
+
+namespace blifparse {
+
+/*
+ * Function Declarations
+ */
+
+struct Names {
+    std::vector<std::string> nets;
+    std::vector<std::vector<LogicValue>> so_cover;
+};
+
+struct SubCkt {
+    std::string model;
+    std::vector<std::string> ports;
+    std::vector<std::string> nets;
+};
+
+} //namespace
+#endif

src/blif_common.hpp

@@ -0,0 +1,69 @@
+#include <cstdarg>
+#include <cassert>
+#include "blif_error.hpp"
+#include "blifparse.hpp"
+
+namespace blifparse {
+
+std::string escape_string(const std::string& near_text);
+
+//We wrap the actual blif_error to issolate custom handlers from vaargs
+void blif_error_wrap(Callback& callback, const int line_no, const std::string& near_text, const char* fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+
+    //We need to copy the args so we don't change them before the true formating
+    va_list args_copy;
+    va_copy(args_copy, args);
+
+    //Determine the formatted length using a copy of the args
+    int len = std::vsnprintf(nullptr, 0, fmt, args_copy); 
+
+    va_end(args_copy); //Clean-up
+
+    //Negative if there is a problem with the format string
+    assert(len >= 0 && "Problem decoding format string");
+
+    size_t buf_size = len + 1; //For terminator
+
+    //Allocate a buffer
+    //  unique_ptr will free buffer automatically
+    std::unique_ptr<char[]> buf(new char[buf_size]);
+
+    //Format into the buffer using the original args
+    len = std::vsnprintf(buf.get(), buf_size, fmt, args);
+
+    va_end(args); //Clean-up
+
+    assert(len >= 0 && "Problem decoding format string");
+    assert(static_cast<size_t>(len) == buf_size - 1);
+
+    //Build the string from the buffer
+    std::string msg(buf.get(), len);
+
+    //TODO: escape near_text
+    std::string escaped_near_text = escape_string(near_text);
+
+    //Call the error handler
+    callback.parse_error(line_no, escaped_near_text, msg);
+}
+
+std::string escape_string(const std::string& near_text) {
+    std::string escaped_text;
+
+    for(char c : near_text) {
+
+        if(c == '\n') {
+            escaped_text += "\\n";
+        } else if(c == '\r') {
+            escaped_text += "\\r";
+        } else {
+            escaped_text += c;
+        }
+    }
+
+    return escaped_text;
+}
+
+
+}

src/blif_error.cpp

@@ -0,0 +1,9 @@
+#ifndef BLIF_ERROR_H
+#define BLIF_ERROR_H
+#include <functional>
+#include "blifparse.hpp"
+namespace blifparse {
+
+    void blif_error_wrap(Callback& callback, const int line_no, const std::string& near_text, const char* fmt, ...);
+}
+#endif

src/blif_error.hpp

@@ -0,0 +1,35 @@
+#include "blif_lexer.hpp"
+
+//Windows doesn't have unistd.h, so we set '%option nounistd' 
+//in blif_lexer.l, but flex still includes it in the generated 
+//header unless YY_NO_UNISTD_H is defined to 1
+#define YY_NO_UNISTD_H 1
+#include "blif_lexer.gen.hpp" //For blifparse_lex_*()
+
+extern YY_DECL; //For blifparse_lex()
+
+namespace blifparse {
+
+Lexer::Lexer(FILE* file, Callback& callback)
+    : callback_(callback) {
+    blifparse_lex_init(&state_);
+    blifparse_set_in(file, state_);
+}
+
+Lexer::~Lexer() {
+    blifparse_lex_destroy(state_);
+}
+
+Parser::symbol_type Lexer::next_token() {
+    return blifparse_lex(state_, callback_);
+}
+
+const char* Lexer::text() const {
+    return blifparse_get_text(state_);
+}
+
+int Lexer::lineno() const {
+    return blifparse_get_lineno(state_);
+}
+
+}