Web alhem.net

mydp.cpp

Go to the documentation of this file.

/*
Copyright (C) 2004  Anders Hedstrom

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
#include <stdio.h>
#include <string>
#include <sys/types.h>
#include <dirent.h>
#include <vector>
#include <sys/stat.h>
#include <unistd.h>
#include <map>
#include "Parse.h"

#include "Token.h"
#include "MyParser.h"
#include "mydp.h"
#include "Scope.h"

#define DEB(x)


/* This is a comment */

namespace ugly { 
        int beep; 
}

        config_m config;
        std::string includes = "";

void read_makefile()
{
        FILE *fil;
        if ((fil = fopen("Makefile","rt")) != NULL)
        {
                char slask[1000];
                fgets(slask,1000,fil);
                while (!feof(fil))
                {
                        Parse pa(slask);
                        strcpy(slask,pa.getword().c_str());
                        while (*slask)
                        {
                                if (!strncmp(slask,"-I",2))
                                {
                                        if (includes.size())
                                                includes += " ";
                                        includes += slask;
                                }
                                //
                                strcpy(slask,pa.getword().c_str());
                        }
                        //
                        fgets(slask,1000,fil);
                }
                fclose(fil);
        }
}


void print_parent(Scope *p)
{
        if (!p)
                return;
        if (p -> GetParent())
        {
                print_parent(p -> GetParent());
                p -> Tab();
                printf("%s\n",p -> GetExpr().c_str());
        }
}


void class_recursive(Scope *root)
{
        sequence_v::iterator it = root -> ScopeBegin();
        Token *t = root -> GetFirstToken();

        if (t)
        {
                if (t -> GetCode() == Class)
                {
                        print_parent( root -> GetParent() );
                        root -> Tab();
                        printf("%s",root -> GetExpr().c_str());
                        if (root -> IsExtern())
                                printf("  <extern>");
                        printf("\n");
                        root -> Tab();
                        printf("\tFile: %s:%d\n",root -> GetFile().c_str(),root -> GetLine());
                        printf("\n");
                }
                else
                if (t -> GetCode() == Template)
                {
                        token_v::iterator it = root -> Begin();
                        int lvl = 0;
                        while (it != root -> End())
                        {
                                Token *t = *it;
                                if (t)
                                {
                                        if (t -> GetCode() == '<')
                                                lvl++;
                                        else
                                        if (t -> GetCode() == '>')
                                                lvl--;
                                        else
                                        {
                                                if (!lvl && it != root -> Begin())
                                                {
                                                        if (t -> GetCode() == Class)
                                                        {
                                                                print_parent( root -> GetParent() );
                                                                root -> Tab();
                                                                printf("%s",root -> GetExpr().c_str());
                                                                if (root -> IsExtern())
                                                                        printf("  <extern>");
                                                                printf("\n");
                                                                root -> Tab();
                                                                printf("\tFile: %s:%d\n",root -> GetFile().c_str(),root -> GetLine());
                                                                printf("\n");
                                                        }
                                                        else
                                                        {
                                                        }
                                                        break;
                                                }
                                        }
                                }
                                //
                                it++;
                        }
                }
        }

        while (it != root -> ScopeEnd())
        {
                Sequence *p = *it;
                Scope *scope = dynamic_cast<Scope *>(p);
                if (scope)
                {
                        class_recursive( scope );
                }
                //
                it++;
        }
}


void class_hierarchy(Scope *root)
{
        class_recursive(root);
}


void parse_file(const std::string &path,const std::string &filename)
{
        std::string cmd;
        std::string out;
        if (config["-cpp"] != "true")
        {
                out = path + "/" + filename + ".preprocessed";
                cmd = "/usr/bin/cpp"
                        " -C" 
                        " " + includes +
                        " " + path + "/" + filename + " > " + out;
fprintf(stderr,"%s\n", cmd.c_str());
                if (system( cmd.c_str() ) == -1)
                {
DEB(                    fprintf(stderr,"Command failed: '%s'...\n",cmd.c_str());)
                        return;
                }
        }
        else
        {
                out = path + "/" + filename + ".preprocessed";
                cmd = "cat"
                        " " + path + "/" + filename + " > " + out;
fprintf(stderr,"%s\n", cmd.c_str());
                if (system( cmd.c_str() ) == -1)
                {
DEB(                    fprintf(stderr,"Command failed: '%s'...\n",cmd.c_str());)
                        return;
                }
        }

        FILE *fil = fopen(out.c_str(),"rt");
        if (fil)
        {
                MyParser p(path);
                std::string name;
                Scope *result;
                name = path + "/";
                name += filename;
                result = p.Parser(fil,name);
                fclose(fil);
                unlink(out.c_str());
                //
                if (config["-xml"] == "true")
                {
                        printf("<?xml version=\"1.0\"?>\n");
                        printf("<code>\n");
                        result -> Display();
                        printf("</code>\n");
                }
                else
                if (config["-disp"] == "true")
                        result -> Display();
                else
                        class_hierarchy( result );
                delete result;
        }
        else
        {
                fprintf(stderr,"Couldn't open '%s'...\n",filename.c_str());
                return;
        }
}


int main(int argc,char *argv[])
{
        char *args[] = {"-disp","-xml","-cpp",""};
        read_makefile();
        if (includes.size())
                fprintf(stderr,"Using include path(s): %s\n",includes.c_str());
        if (argc == 1)
        {
                fprintf(stderr,"Usage: %s [-cpp] [-disp] [-xml] file(s)\n",*argv);
                fprintf(stderr," -cpp     Don't use cpp precompiler\n");
                fprintf(stderr," -disp    View parsed and formatted source code\n");
                fprintf(stderr," -xml     View parsed code as xml\n");
                return 0;
        }
        for (int i = 1; i < argc; i++)
        {
                bool ok = false;
                bool more = false;
                int x = 0;
                while (*args[x])
                {
                        if (!strcmp(argv[i],args[x]))
                        {
                                ok = true;
                                // check for more
                                break;
                        }
                        else
                        {
                                x++;
                        }
                }
                if (ok)
                {
                        if (more)
                        {
                                config[argv[i]] = argv[i + 1];
                                i++;
                        }
                        else
                        {
                                config[argv[i]] = "true";
                        }
                }
                else
                {
                        parse_file(".", argv[i]);
                }
        }
}

---