imlib3d-code-generation.cpp

#include<ImLib3D/ImageProcessorsDescription.hpp>
#include<ImLib3D/XMLTools.hpp>
#include<ImLib3D/Base64.hpp>
#include <stdexcept>


void DeclareArg(XIPD::Argument arg,int j,string &out);
void
GenerateDefinitionsStandardTemplated(ImageProcessorsDescription &imProcsDescription,vector<string> procNames,string &out);
void
GenerateDefinitionsStandardNonTemplated(ImageProcessorsDescription &imProcsDescription,vector<string> procNames,string &out);
void
GenerateTemplateGroups(ImageProcessorsDescription &imProcsDescription,vector<string> procNames,string &out);
void
GenerateCalls(ImageProcessorsDescription &imProcsDescription,vector<string> procNames,string &out);
void
GenerateHardCodedDescription(string xmlDescriptionFile,string  &out);
void
GeneratePlugin(ImageProcessorsDescription &imProcsDescription,vector<string> procNames,string xmlDescriptionFile,string userHeader,string &out);

void
WriteStringToFileIfChanged(const string &fname,const string &data);


string warning="// *************** DO NOT MODIFY!!! ***********\n//  ** AUTOMATICALLY GENERATED SRC CODE **\n\n";

string definitionsFilename="ImageProcessorsByNameDefinitions.cpp";
string callsFilename="ImageProcessorsByNameCalls.cpp";
string templateGroupsFilename="TemplateGroups.hpp";

void
Usage()
{
    printf("Usage:\n");
    printf("imlib3d-code-generation --definitions     descriptions.xml %s [--extra-description=extra.xml]\n",definitionsFilename.c_str());
    printf("imlib3d-code-generation --calls           descriptions.xml %s [--extra-description=extra.xml]\n",callsFilename.c_str());
    printf("imlib3d-code-generation --template-groups descriptions.xml %s \n",templateGroupsFilename.c_str());
    printf("imlib3d-code-generation --hardcode        source dest\n");
    printf("imlib3d-code-generation --plugin          descriptions.xml Header.hpp Plugin.cpp [extra.xml] \n");
    ThrowError("bad commandline");
    exit(1);
}

string
ParseOptionalArg(vector<string> &args,const string &name)
{
    string baseName=name;
    bool hasValue=false;
    if(name.size() && name[name.size()-1]=='=')
    {
        hasValue=true;
    }
    for(uint i=0;i<args.size();i++)
    {
        if(args[i].size()>=baseName.size() && 
           args[i].substr(0,baseName.size())==baseName)
        {
            string arg=args[i];
            args.erase(args.begin()+i);
            if(hasValue)
            {
                return arg.substr(name.size());
            }
            else
            {
                return "yes";
            }
        }
    }
    return "";
}
int
main(int argc,char **argv)
{
    vector<string> args;
    for(int i=1;i<argc;i++){args.push_back(argv[i]);}
    
    SetErrorManagementType(ERROR_USE_EXCEPTIONS);

    if(args.size()==0){Usage();}


    if(args[0]=="--definitions" ||
       args[0]=="--calls"       ||
       args[0]=="--template-groups"       ||
       args[0]=="--plugin"         )
    {
        // optionally mergein another description, for extra info (such as types)
        string extraDescription=ParseOptionalArg(args,"--extra-description=");
        string xmlDescriptionFile=args[1];
        string outputFile=args[2];
        string out=warning;
        ImageProcessorsDescription imProcsDescription;
        imProcsDescription.ReadFromFile(xmlDescriptionFile);
        vector<string> procNames=imProcsDescription.GetNames(true);
        if(extraDescription!="")
        {
            // when generating for plugins, it is usefull to give the main XML description file.
            // That way you can use  the normal template groups
            ImageProcessorsDescription extra;
            extra.ReadFromFile(extraDescription);
            imProcsDescription.Merge(extra);
        }
        
        if(args[0]=="--definitions")
        {
            if(args.size()!=3){Usage();}
            GenerateDefinitionsStandardTemplated(imProcsDescription,procNames,out);
            GenerateDefinitionsStandardNonTemplated(imProcsDescription,procNames,out);
        }
        else
        if(args[0]=="--calls")
        {
            if(args.size()!=3){Usage();}
            GenerateCalls(imProcsDescription,procNames,out);
        }
        else
        if(args[0]=="--template-groups")
        {
            if(args.size()!=3){Usage();}
            GenerateTemplateGroups(imProcsDescription,procNames,out);
        }
        else
        if(args[0]=="--plugin")
        {
            if(args.size()!=4){Usage();}
            outputFile=args[3];
            GeneratePlugin(imProcsDescription,procNames,xmlDescriptionFile,args[2],out);
        }
        else
        {
            ThrowError("imlib3d-code-generation: incoherence!");
        }
        WriteStringToFileIfChanged(outputFile,out);
        exit(0);
    }
    if(args[0]=="--hardcode")
    {
        if(args.size()!=3){Usage();}
        // hardcode file into string using base64 encoding
        string srcData=args[1];
        string destFile=args[2];
        string out;
        GenerateHardCodedDescription(srcData,out);
        WriteStringToFileIfChanged(destFile,out);
        exit(0);
    }
    Usage();
}
void
GenerateDefinitionsStandardTemplated(ImageProcessorsDescription &imProcsDescription,vector<string> procNames,string &out)
{
    // ******************* generate standard templated ***********************
    for(uint i=0;i<procNames.size();i++)
    {
        try{
        string procName=procNames[i];
        XIPD::ImageProcessor proc=*imProcsDescription.GetImageProcessor(procName);
        if(proc.type!="standard templated"){continue;}
        // generate function declaration
        out+="template<class ImageType >\n";
        out+="void\n";
        out+="ImProc_"+procName+"_";
        out+="StrArgs(const string &procName,const vector<string> &args,vector<TypeSafeGenericPointer> &alternateArgs)\n";
        out+="{\n";
        if(proc.conditional!=""){out+="#ifdef "+proc.conditional+"\n";}
        out+="\ttypedef typename ImageType::value_type Im3DValue;\n";
        // generate argument declarations and initialisations
        for(uint j=0;j<proc.arguments.size();j++){DeclareArg(proc.arguments[j],j,out);}
        // generate actual call to image processor
        out+="\tIP3D::"+procName+"(";
        for(uint j=0;j<proc.arguments.size();j++)
        {
            out+=(j>0 ? ", " : "")+
                string(proc.arguments[j].optType=="pointer" ? "&" : "")+
                SPrintf("arg%d",j);
        }
        out+=");\n";
        // generate output res and cleanup 
        for(uint j=0;j<proc.arguments.size();j++)
        {
            XIPD::Argument arg=proc.arguments[j];
            if(arg.direction=="output"  && arg.ignoreOutput!="yes")
            {
                out+="\tImProcOutputArg< "+arg.type+" >("+SPrintf("arg%d",j)+","
                    +SPrintf("args[%d]",j)+",alternateArgs,"+SPrintf("%d",j)+");\n";
            }
            if(arg.isOptional!="true" || arg.optType=="pointer")
            {
                out+="\tCleanupArg< "+arg.type+" >("+SPrintf("arg%d",j)+",alternateArgs,"+SPrintf("%d",j)+");\n";
            }
        }

        if(proc.conditional!="")
        {
            out+="#else\n    ThrowError(\"support for "+procName+" was not compiled\");\n#endif\n";
        }
        out+="}\n";
        }catch(std::exception& __fail){ThrowError("problem in parsing processor \"%s\"",procNames[i].c_str());}
    }
}

void
GenerateDefinitionsStandardNonTemplated(ImageProcessorsDescription &imProcsDescription,vector<string> procNames,string &out)
{
    // ******************* generate standard non templated ***********************

    for(uint i=0;i<procNames.size();i++)
    {
        try
        {
        string procName=procNames[i];
        XIPD::ImageProcessor proc=*imProcsDescription.GetImageProcessor(procName);
        if(proc.type!="standard"){continue;}
        out+="void\n";
        out+="ImProc_"+procName+"_";
        out+="StrArgs(const string &procName,const vector<string> &args,vector<TypeSafeGenericPointer> &alternateArgs)\n";
        out+="{\n";
        if(proc.conditional!=""){out+="#ifdef "+proc.conditional+"\n";}
        // generate argument declarations and initialisations
        for(uint j=0;j<proc.arguments.size();j++){DeclareArg(proc.arguments[j],j,out);}
        // generate actual call to image processor
        out+="\tIP3D::"+procName+"(";
        for(uint j=0;j<proc.arguments.size();j++)
        {
            out+=(j>0 ? ", " : "")+
                string(proc.arguments[j].optType=="pointer" ? "&" : "")+
                SPrintf("arg%d",j);
        }
        out+=");\n";
        // generate output res and cleanup 
        for(uint j=0;j<proc.arguments.size();j++)
        {
            XIPD::Argument arg=proc.arguments[j];
            if(arg.direction=="output")
            {
                out+="\tImProcOutputArg< "+arg.type+" >("+SPrintf("arg%d",j)+","+
                    SPrintf("args[%d]",j)+",alternateArgs,"+SPrintf("%d",j)+");\n";
            }
            if(!(arg.isOptional=="true") || arg.optType=="pointer")
            {
                out+="\tCleanupArg< "+arg.type+" >("+SPrintf("arg%d",j)+",alternateArgs,"+SPrintf("%d",j)+");\n";
            }
        }

        if(proc.conditional!="")
        {
            out+="#else\n    ThrowError(\"support for "+procName+" was not compiled\");\n#endif\n";
        }
        out+="}\n";
        }
        catch(std::exception& __fail)
        {
            ThrowError("problem in parsing processor \"%s\"",procNames[i].c_str());
        }
    }
}
void
GenerateCalls(ImageProcessorsDescription &imProcsDescription,vector<string> procNames,string &out2)
{
    // ******************* generate  improc fct calls ***********************
    out2+="void StandardImProcCalls(const string &procName,const vector<string> &args,string typeName,vector<TypeSafeGenericPointer> alternateArgs=vector<TypeSafeGenericPointer>())\n{\n";
    for(uint i=0;i<procNames.size();i++)
    {
        try{
        string procName=procNames[i];
        XIPD::ImageProcessor proc=*imProcsDescription.GetImageProcessor(procName);
        string fct="ImProc_"+procName+"_StrArgs";
        if(proc.type=="standard templated")
        {
            string group=proc.templateGroup;
            // this only checks if template group is valid
            if(!imProcsDescription.GetTemplateGroup(group))
            {
                printf("Warning: template group \"%s\" is not described\n",group.c_str());
            }

            string macroName= "CallWith"+group+"_3";
            out2+="    if(procName==\""+procName+"\"){"+macroName+"("+fct+",typeName,procName,args,alternateArgs);}\n";
            out2+="    else\n";
        }
        else
        if(proc.type=="standard")
        {
            out2+="    if(procName==\""+procName+"\"){"+fct+"(procName,args,alternateArgs);}\n";
            out2+="    else\n";         
        }
        }catch(std::exception& __fail){ThrowError("problem in parsing processor \"%s\"",procNames[i].c_str());}
    }
    out2+="    {ThrowError(\"unimplemented call by name image processor interface for:\\\"%s\\\"please report this bug\",procName);}\n";
    out2+="}\n";
//      cout << out << endl;        
}


void
GenerateHardCodedDescription(string xmlDescriptionFile,string  &out)
{
    string fileContents;
    int dataSize;
    // in case we are encoding binary data, we read file as binary
    void *data=Read(xmlDescriptionFile,&dataSize,true);
    char *cdata=(char *)data;
    fileContents.reserve(dataSize);
    for(int i=0;i<dataSize;i++){fileContents+=cdata[i];}
    // now generate code : string hardcodedDescription("jhlkjh...");
    out+="string hardcodedDescription(\n\t\"";
    // we need to split encoded string into several lines to avoid overflows :-(
    string encoded=Base64::Encode(fileContents);
    for(uint i=0;i<encoded.size();i++)
    {
        if(i>0 && !(i%80)){out+="\"\n\t\"";}
        out+=encoded[i];
    }
    out+="\");\n";

    delete [] cdata;
}

void
GenerateTemplateGroups(ImageProcessorsDescription &imProcsDescription,vector<string> procNames,string &out)
{
    printf(" found %d template groups\n",imProcsDescription.templateGroups.size());
    for(uint i=0;i<imProcsDescription.templateGroups.size();i++)
    {
        XIPD::TemplateGroup &group=imProcsDescription.templateGroups[i];
        uint maxNbArgs=5;
        for(uint nbArgs=0;nbArgs<maxNbArgs;nbArgs++)
        {
            string macroName= "CallWith"+group.name+SPrintf("_%d",nbArgs);
            out+="#define "+macroName+"(fct,typeName";
            for(uint j=0;j<nbArgs;j++){out+=SPrintf(",a%d",j);}
            out+=")\\\n";
            for(uint j=0;j<group.types.size();j++)
            {           
                string type=group.types[j];
                out+="    if(typeName==\""+type+"\"){fct< "+type+" >(";
                for(uint k=0;k<nbArgs;k++){out+=(k>0 ? "," : "")+SPrintf("a%d",k);}
                out+=");}\\\n";
                out+="    else\\\n";
            }
            out+="    {ThrowError(\""+macroName+" failed, type \\\"%s\\\" is not in template group \\\""+
                group.name+"\\\"\",typeName);}\n";
        }
    }
}
void
GeneratePlugin(ImageProcessorsDescription &imProcsDescription,vector<string> procNames,string xmlDescriptionFile,string userHeader,string &out)
{
    out+="#include<ImLib3D/ImLib3D.hpp>\n";
    out+="#include<ImLib3D/TemplateGroups.hpp>\n\n";

    out+="#include<ImLib3D/StringArgumentConversion.hpp>\n\n";
    out+="#include\""+userHeader+"\"\n\n";

    GenerateDefinitionsStandardTemplated(imProcsDescription,procNames,out);
    GenerateDefinitionsStandardNonTemplated(imProcsDescription,procNames,out);
    GenerateCalls(imProcsDescription,procNames,out);

    GenerateHardCodedDescription(xmlDescriptionFile,out);
    out+="\n";
    out+="#include<ImLib3D/UserPlugin.hpp>\n\n";
    out+="int\nmain(int argc,char **argv)\n{\n";
    out+="\tUserPluginMain(argc,argv);\n";
    out+="\treturn 0;\n}\n";

//  bool CustomImProcCalls(const string &procName,const vector<string> &args,const string typeName,
//                         vector<TypeSafeGenericPointer> alternateArgs)
//  {
//      return false;
//  }


}

void
DeclareArg(XIPD::Argument iparg,int j,string &out)
{
    string type=iparg.type;
    string arg=SPrintf(" arg%d ",j);
    string str=SPrintf(" args[%d] ",j);
    if(!(iparg.isOptional=="true"))
    {
        if(iparg.direction!="output")
        {
            out+="\t"+type+"&"+arg+"=*StringOrAlternateInputArg<"+type+" >("+str+",alternateArgs,"+SPrintf("%d ",j)+");\n";
        }
        else
        {
            out+="\t"+type+"&"+arg+"=*CreateOutputArg<"+type+" >(alternateArgs,"+SPrintf("%d ",j)+");\n";
        }
    }
    else
    {
        if(iparg.direction!="output")
        {
            if(iparg.optType=="pointer")
            {
                out+="\t"+type+"&"+arg+"=*OptionalPointerArg<"+type+" >("+str+",alternateArgs,"+SPrintf("%d ",j)+");\n";
            }
            else
            {
                string def=iparg.defaultValue;
                if(def=="" ){ThrowError("No default value for opt arg \"%s\" ",iparg.name);}
                out+="\t"+type+"&"+arg+"=*OptionalDefaultValueArg<"+type+" >("+str+",alternateArgs,"+SPrintf("%d ",j)+","+def+");\n";
            }
        }
        else
        {
            if(iparg.optType=="pointer")
            {
                out+="\t"+type+"&"+arg+"=*OptionalPointerArgCreateOutput<"+type+" >("+str+",alternateArgs,"+SPrintf("%d ",j)+");\n";
//                  out+="\t"+type+"*"+arg+"=NULL;\n";
//                  out+="\tif("+str+"!=\"\"){"+arg+"= new "+type+"();}\n";
            }
            else
            {
//              out+="\t"+type+arg+";\n";
                ThrowError("optional default value output arg is not supported!!\n");
            }
        }
    }
}


void
WriteStringToFileIfChanged(const string &fname,const string &data)
{
    string tmp=WriteTmpFile(data);
    if(!FileExists(fname) || system(SPrintf("diff -q -N %s %s",fname,tmp).c_str())!=0)
    {
        mprintf("%s has changed, actually modifying\n",fname);
        WriteStringToFile(fname,data);
    }
    RemoveFile(tmp);
}

---