ctrump/parser/CFront.cpp

Go to the documentation of this file.

/*
 Copyright (c) 2009, National Institute of Advanced Industrial Science
 and Technology.  All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:
 
   * Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
 
   * Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution.
 
   * Neither the name of Fixstars Corporation nor the names of its
     contributors may be used to endorse or promote products derived
     from this software without specific prior written permission.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT
 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include <antlr/CommonAST.hpp>
#include <antlr/AST.hpp>
#include <antlr/ASTFactory.hpp>
#include "CLexer.hpp"
#include "CParser.hpp"
#include "AstConverter.hpp"
#include "CToken.hpp"
#include "LocationNode.hpp"
#include "ctrump/ctrump.h"
#include "ctrump/ast/abi.h"
#include "ctrump/io/pretty-printer.h"
#include "cfront.h"
#include <fstream>
#include <iostream>

using namespace cfront;

void
makeTargetInfo(const ctrump_abi* abi, TargetInfo& info)
{
    info.setSize(TargetInfo::POINTER, abi->sizeof_pointer);
    info.setSize(TargetInfo::BOOL, abi->sizeof_bool);
    //info.setSize(TargetInfo::CHAR, abi->sizeof_char);
    info.setSize(TargetInfo::SHORT, abi->sizeof_short);
    info.setSize(TargetInfo::INT, abi->sizeof_int);
    info.setSize(TargetInfo::LONG, abi->sizeof_long);
    info.setSize(TargetInfo::LLONG, abi->sizeof_longlong);
    info.setSize(TargetInfo::FLOAT, abi->sizeof_float);
    info.setSize(TargetInfo::DOUBLE, abi->sizeof_double);
    //info.setSize(TargetInfo::LDOUBLE, abi->sizeof_longdouble);
    info.setSize(TargetInfo::ENUM, abi->sizeof_enum);
    info.setSize(TargetInfo::VECTOR, abi->sizeof_vector);

    info.setAlign(TargetInfo::POINTER, abi->alignof_pointer);
    info.setAlign(TargetInfo::BOOL, abi->alignof_bool);
    //info.setAlign(TargetInfo::CHAR, abi->alignof_char);
    info.setAlign(TargetInfo::SHORT, abi->alignof_short);
    info.setAlign(TargetInfo::INT, abi->alignof_int);
    info.setAlign(TargetInfo::LONG, abi->alignof_long);
    info.setAlign(TargetInfo::LLONG, abi->alignof_longlong);
    info.setAlign(TargetInfo::FLOAT, abi->alignof_float);
    info.setAlign(TargetInfo::DOUBLE, abi->alignof_double);
    //info.setAlign(TargetInfo::LDOUBLE, abi->alignof_longdouble);
    info.setAlign(TargetInfo::ENUM, abi->alignof_enum);
    info.setAlign(TargetInfo::VECTOR, abi->alignof_vector);
}

void
setInternalError(Logs& logs, const char* message, const Location* loc,
                 const char* originalFilename)
{
    int line = 0;
    int col = 0;
    const char* errorFilename = originalFilename;
    if (loc != NULL) {
        line = loc->line;
        col = loc->column;
        errorFilename = loc->filePath.c_str();
    }
    ERROR_BASIC(CTRUMP_ERR_INTERNAL_ERROR, "internal error: %s"
                , errorFilename, line, col, &logs, message, NULL);
}

void
convertLogs(Logs& logs, struct ctrump_loginfo** log_info, int* num_log_info,
            struct ctrump_mempool *tree_pool)
{
    *num_log_info = logs.size();
    *log_info = (ctrump_loginfo*)
        ctrump_mempool_alloc(tree_pool,
                             *num_log_info * sizeof(ctrump_loginfo));
    std::copy(logs.begin(), logs.end(), *log_info);
}

int
ctrump_parse(struct ctrump_loginfo** log_info,
             int* num_log_info,
             struct ctrump_translation_unit *result,
             const char *filename,
             const char *original_filename,
             struct ctrump_type_env *type_env,
             const struct ctrump_abi *abi,
             const struct ctrump_parser_option *option,
             int id_base,
             struct ctrump_mempool *tree_pool)
{
    Logs logs;
    antlr::RefAST ast = NULL;

    try {
        std::ifstream in(filename);
        if (!in.is_open()) {
            std::cerr << filename << " : No such file or directory.\n";
            return -1;
        }
        TargetInfo targetInfo;
        ParserLexerSharedState sharedState;

        CLexer lexer(in);
        lexer.setTokenObjectFactory(CToken::factory);
        lexer.setParserSharedState(&sharedState);
        lexer.setCurrentSource(filename);
        lexer.setLine(1);

        CAnalyzer analyzer;
        analyzer.initialize();
        analyzer.setLogs(&logs);
        makeTargetInfo(abi, targetInfo);
        analyzer.setTargetInfo(&targetInfo);
        analyzer.setSupportVectorExtension(option->is_vector_keyword != 0);

        CParser parser(lexer);
        parser.setLogs(&logs);
        parser.setLexerSharedState(&sharedState);
        antlr::ASTFactory astFactory("ValueNode", ValueNode::factory);
        parser.initializeASTFactory(astFactory);
        analyzer.setASTFactory(&astFactory);
        parser.setASTFactory(&astFactory);
        parser.setAnalyzer(&analyzer);

        parser.translationUnit();

        ast = parser.getAST();
    } catch (UncontinuableError& e) {
        /* do nothing. */
    } catch (InternalError& e) {
        setInternalError(logs, e.getMessage(), e.getLocation(),
                         original_filename);
    } catch (antlr::ANTLRException& e) {
        ERROR_BASIC(CTRUMP_ERR_UNEXPECTED_PARSER_ERROR, "unexpected parser error."
                    , original_filename, 0, 0, &logs, NULL);
        std::cout << "exception: " << e.getMessage() << std::endl;
    } catch (std::exception& e) {
        ERROR_BASIC(CTRUMP_ERR_UNEXPECTED_PARSER_ERROR, "unexpected parser error."
                    , original_filename, 0, 0, &logs, NULL);
        std::cout << "exception: " << e.what() << std::endl;
    }

    if (!logs.empty()) {
        /* error occured. */
        convertLogs(logs, log_info, num_log_info, tree_pool);
        return -1;
    }

#ifdef SHOW_AST
    if (ast != NULL) {
        std::cout << ast->toStringList() << std::endl;
    } else {
        std::cout << "(Error occured?)\n";
    }
#endif

    int numCreatedNodes = -1;
    try {
        /* converter */
        ctrump_init_all();

        AstConverter converter(type_env, tree_pool, id_base, &logs);
        converter.translationUnit(RefNode(ast), result);
        result->filename = original_filename;

        numCreatedNodes = converter.getNextId();
    } catch (InternalError& e) {
        setInternalError(logs, e.getMessage(), e.getLocation(),
                         original_filename);
    } catch (antlr::ANTLRException e) {
        ERROR_BASIC(CTRUMP_ERR_UNEXPECTED_PARSER_ERROR, "unexpected parser error."
                    ,filename, 0, 0, &logs, NULL);
        //std::cout << "exception: " << e.getMessage() << std::endl;
    } catch (std::exception& e) {
        ERROR_BASIC(CTRUMP_ERR_UNEXPECTED_PARSER_ERROR, "unexpected parser error."
                    ,filename, 0, 0, &logs, NULL);
        //std::cout << "exception: " << e.what() << std::endl;
    }

    if (!logs.empty()) {
        /* error occured. */
        convertLogs(logs, log_info, num_log_info, tree_pool);
        return -1;
    }
    return numCreatedNodes;
}


void
ctrump_get_default_parser_option(struct ctrump_parser_option *option)
{
    option->is_vector_keyword = 1;
    option->tab_width = 4;
}

#ifdef BUILD_CFRONT

extern "C" void ctrump_destroy_symtab(void);

#include <sys/time.h>

unsigned long long
getTimeDiff(struct timeval* t1, struct timeval* t2)
{
    unsigned long long tl1 =
        (unsigned long long) t1->tv_sec * 1000000 + t1->tv_usec;
    unsigned long long tl2 =
        (unsigned long long) t2->tv_sec * 1000000 + t2->tv_usec;
    return tl1 - tl2;
}

int
main(int argc, char** argv)
{
    struct ctrump_translation_unit tuResult;
    struct ctrump_type_env type_env;
    struct ctrump_mempool tree_allocator;
    struct ctrump_loginfo* log_info;
    struct ctrump_parser_option option;
    int num_log_info;
    struct timeval tstart, tend;

    if (argc < 2) {
        std::cerr << "no input files.\n";
        return 1;
    }

    ctrump_type_env_init(&type_env, 0);
    ctrump_mempool_init(&tree_allocator, 1024);
    ctrump_get_default_parser_option(&option);

    gettimeofday(&tstart, NULL);
    int res = ctrump_parse(&log_info, &num_log_info, &tuResult, argv[1],
                           argv[1], &type_env, &ctrump_ppc32_abi, &option,
                           0, &tree_allocator);
    gettimeofday(&tend, NULL);
    std::cout << "<<all>> <(" << getTimeDiff(&tend, &tstart) << ")>\n";
    int resCode = 0;
    if (res < 0) {
        for (int i = 0; i < num_log_info; i++) {
            ctrump_report_log(&log_info[i]);
            ctrump_free_log(&log_info[i]);
        }
        resCode = 1;
        goto end;
    }
#ifdef USE_PRETTY_PRINTER
    char* retStr;
    int retLen;
    ctrump_print_translation_unit(&retStr, &retLen, 0, 0, &tuResult);
    std::cout << retStr << std::endl;
#endif
    ctrump_destroy_symtab();
 end:
    ctrump_type_env_destroy(&type_env);
    ctrump_mempool_destroy(&tree_allocator);
    return resCode;
}

#endif

---