VuoCompilerMakeListNodeClass.cc

Go to the documentation of this file.

 
#include <sstream>
 
#include "VuoGenericType.hh"
#include "VuoStringUtilities.hh"
 
#include "VuoCompiler.hh"
#include "VuoCompilerCodeGenUtilities.hh"
#include "VuoCompilerConstantsCache.hh"
#include "VuoCompilerGenericType.hh"
#include "VuoCompilerInputDataClass.hh"
#include "VuoCompilerInputEventPortClass.hh"
#include "VuoCompilerMakeListNodeClass.hh"
#include "VuoCompilerOutputDataClass.hh"
#include "VuoCompilerOutputEventPortClass.hh"
#include "VuoCompilerPort.hh"
#include "VuoNodeClass.hh"
#include "VuoPort.hh"
 
 
const string VuoCompilerMakeListNodeClass::makeListNodeClassNamePrefix = "vuo.list.make.";
 
const string VuoCompilerMakeListNodeClass::makeListNodeClassDescription = "Creates a list from the given items.";
 
 
VuoCompilerMakeListNodeClass::VuoCompilerMakeListNodeClass(string nodeClassName, Module *module) :
    VuoCompilerSpecializedNodeClass(nodeClassName, module)
{
    initialize();
}
 
VuoCompilerMakeListNodeClass::VuoCompilerMakeListNodeClass(VuoCompilerMakeListNodeClass *compilerNodeClass) :
    VuoCompilerSpecializedNodeClass(compilerNodeClass)
{
    initialize();
}
 
VuoCompilerMakeListNodeClass::VuoCompilerMakeListNodeClass(VuoNodeClass *baseNodeClass) :
    VuoCompilerSpecializedNodeClass(baseNodeClass)
{
    initialize();
}
 
void VuoCompilerMakeListNodeClass::initialize(void)
{
    itemCount = 0;
    listType = NULL;
}
 
VuoNodeClass * VuoCompilerMakeListNodeClass::newNodeClass(string nodeClassName, VuoCompiler *compiler, dispatch_queue_t llvmQueue)
{
    unsigned long itemCount;
    string itemTypeStr;
    bool parsedOk = parseNodeClassName(nodeClassName, itemCount, itemTypeStr);
    if (! parsedOk)
        return NULL;
 
    VuoCompilerType *itemType = compiler->getType(itemTypeStr);
    VuoCompilerType *listType = compiler->getType(VuoType::listTypeNamePrefix + itemTypeStr);
    if (! itemType || ! listType)
        return NULL;
 
    __block VuoCompilerMakeListNodeClass *nodeClass;
 
    if (! dynamic_cast<VuoGenericType *>(itemType->getBase()))
    {
        // The generic port types have been specialized, so generate LLVM bitcode for the node class.
 
        dispatch_sync(llvmQueue, ^{
 
                          vector<Type *> itemParamTypes = itemType->getFunctionParameterTypes();
                          AttributeList itemFunctionAttributes = itemType->getFunctionAttributes();
 
                          Module *module = new Module("", *VuoCompiler::globalLLVMContext);
 
                          // VuoModuleMetadata({});
                          VuoCompilerCodeGenUtilities::generateModuleMetadata(module, "{}", "");
 
 
                          // void nodeEvent
                          // (
                          //    VuoInputData(<item type>,<default value>) item1,
                          //    ...,
                          //    VuoInputData(<item type>,<default value>) item<item count>,
                          //    VuoOutputData(VuoList_<item type>) list
                          // )
 
                          vector<VuoPort *> modelInputPorts;
                          for (unsigned long i = 0; i < itemCount; ++i)
                          {
                              ostringstream oss;
                              oss << i+1;
                              string portName = oss.str();
 
                              VuoCompilerInputEventPortClass *modelItemPortClass = new VuoCompilerInputEventPortClass(portName);
                              VuoCompilerInputDataClass *dataClass = new VuoCompilerInputDataClass("");
                              dataClass->setVuoType( itemType->getBase() );
                              modelItemPortClass->setDataClass(dataClass);
                              VuoCompilerPort *modelItemPort = modelItemPortClass->newPort();
 
                              modelInputPorts.push_back( modelItemPort->getBase() );
                          }
 
                          VuoCompilerOutputEventPortClass *modelListPortClass = new VuoCompilerOutputEventPortClass("list");
                          VuoCompilerOutputDataClass *dataClass = new VuoCompilerOutputDataClass("");
                          dataClass->setVuoType( listType->getBase() );
                          modelListPortClass->setDataClass(dataClass);
                          VuoCompilerPort *modelListPort = modelListPortClass->newPort();
                          vector<VuoPort *> modelOutputPorts( 1, modelListPort->getBase() );
                          map<VuoPort *, size_t> indexOfParameter;
                          map<VuoPort *, size_t> indexOfEventParameter;
                          VuoCompilerConstantsCache constantsCache(module);
 
                          Function *eventFunction = VuoCompilerCodeGenUtilities::getNodeEventFunction(module, "", false, false,
                                                                                                      nullptr, modelInputPorts, modelOutputPorts,
                                                                                                      map<VuoPort *, json_object *>(), map<VuoPort *, string>(),
                                                                                                      map<VuoPort *, string>(), map<VuoPort *, VuoPortClass::EventBlocking>(),
                                                                                                      indexOfParameter, indexOfEventParameter, &constantsCache);
 
 
                          // {
                          //        *list = VuoListCreate_<item type>();
                          //        VuoListAppendValue_<item type>(*list, item1);
                          //        ...
                          //        VuoListAppendValue_<item type>(*list, item<item count>);
                          // }
 
                          BasicBlock *block = &(eventFunction->getEntryBlock());
 
                          string itemBackingTypeName;
                          if (VuoGenericType::isGenericTypeName(itemTypeStr))
                          {
                              itemBackingTypeName = VuoCompilerGenericType::chooseBackingTypeName(itemTypeStr, vector<string>());
                          }
                          else
                          {
                              itemBackingTypeName = itemTypeStr;
                          }
 
                          string listCreateFunctionName = "VuoListCreate_" + itemBackingTypeName;
                          Function *listCreateFunctionSrc = listType->getModule()->getFunction(listCreateFunctionName);
                          Function *listCreateFunction = declareFunctionInModule(module, listCreateFunctionSrc);
 
                          string listAppendFunctionName = "VuoListAppendValue_" + itemBackingTypeName;
                          Function *listAppendFunctionSrc = listType->getModule()->getFunction(listAppendFunctionName);
                          Function *listAppendFunction = declareFunctionInModule(module, listAppendFunctionSrc);
 
                          vector<Value *> itemValues;
                          for (VuoPort *itemPort : modelInputPorts)
                          {
                              size_t argIndex = indexOfParameter[itemPort];
                              Value *itemValue = VuoCompilerCodeGenUtilities::getArgumentAtIndex(eventFunction, argIndex);
                              itemValues.push_back(itemValue);
                              if (itemParamTypes.size() > 1)
                              {
                                  Value *itemSecondValue = VuoCompilerCodeGenUtilities::getArgumentAtIndex(eventFunction, argIndex + 1);
                                  itemValues.push_back(itemSecondValue);
                              }
                          }
                          size_t listArgIndex = indexOfParameter[modelListPort->getBase()];
                          Value *listArg = VuoCompilerCodeGenUtilities::getArgumentAtIndex(eventFunction, listArgIndex);
 
                          CallInst *listValue = CallInst::Create(listCreateFunction, "", block);
                          Value *listPointer = VuoCompilerCodeGenUtilities::generatePointerToValue(block, listValue);
                          VuoCompilerCodeGenUtilities::generateMemoryCopy(module, block, listPointer, listArg, listType->getSize(module));
 
                          for (unsigned long i = 0; i < itemCount; ++i)
                          {
                              vector<Value *> listAppendArgs;
                              listAppendArgs.push_back(listValue);
 
                              int itemValuesIndex = (itemParamTypes.size() > 1 ? 2*i : i);
 
                              Value *itemArg = itemValues[itemValuesIndex];
 
                              if (VuoCompilerCodeGenUtilities::isPointerToStruct(itemArg->getType()))
                                  itemArg = new BitCastInst(itemArg, listAppendFunction->getFunctionType()->getParamType(1), "", block);
 
                              listAppendArgs.push_back(itemArg);
 
                              if (itemParamTypes.size() > 1)
                                  listAppendArgs.push_back(itemValues[itemValuesIndex + 1]);
 
                              CallInst *call = CallInst::Create(listAppendFunction, listAppendArgs, "", block);
 
                              VuoCompilerCodeGenUtilities::copyParameterAttributes(module, itemFunctionAttributes, 0, listAppendArgs.size()-1, call, 1);
                          }
 
                          ReturnInst::Create(module->getContext(), block);
 
 
                          for (vector<VuoPort *>::iterator i = modelInputPorts.begin(); i != modelInputPorts.end(); ++i)
                          {
                              delete (*i)->getClass()->getCompiler();
                              delete *i;
                          }
                          delete modelListPort;
                          delete modelListPortClass;
 
 
                          VuoCompilerMakeListNodeClass *dummyNodeClass = new VuoCompilerMakeListNodeClass(nodeClassName, module);
 
                          // Reconstruct, this time with a base VuoNodeClass containing actual (non-dummy) ports.
                          nodeClass = new VuoCompilerMakeListNodeClass(dummyNodeClass);
                          delete dummyNodeClass;
                      });
    }
    else
    {
        // The generic ports have not been specialized, so construct a node class that doesn't yet have an implementation.
 
        VuoPortClass *refreshPortClass = (new VuoCompilerInputEventPortClass("refresh"))->getBase();
 
        vector<VuoPortClass *> inputPortClasses;
        inputPortClasses.push_back(refreshPortClass);
        for (int i = 1; i <= itemCount; ++i)
        {
            ostringstream oss;
            oss << i;
            VuoCompilerInputEventPortClass *portClass = new VuoCompilerInputEventPortClass(oss.str());
            VuoCompilerInputDataClass *dataClass = new VuoCompilerInputDataClass("");
            portClass->setDataClass(dataClass);
            portClass->setDataVuoType(itemType->getBase());
            inputPortClasses.push_back(portClass->getBase());
        }
 
        vector<VuoPortClass *> outputPortClasses;
        {
            VuoCompilerOutputEventPortClass *portClass = new VuoCompilerOutputEventPortClass("list");
            VuoCompilerOutputDataClass *dataClass = new VuoCompilerOutputDataClass("");
            portClass->setDataClass(dataClass);
            portClass->setDataVuoType(listType->getBase());
            outputPortClasses.push_back(portClass->getBase());
        }
 
        VuoNodeClass *baseNodeClass = new VuoNodeClass(nodeClassName, refreshPortClass, inputPortClasses, outputPortClasses);
        nodeClass = new VuoCompilerMakeListNodeClass(baseNodeClass);
    }
 
    nodeClass->itemCount = itemCount;
    nodeClass->listType = listType;
    nodeClass->specializedForGenericTypeName[ VuoGenericType::createGenericTypeName(1) ] = itemTypeStr;
 
    nodeClass->getBase()->setDefaultTitle("Make List");
    nodeClass->getBase()->setDescription(makeListNodeClassDescription);
    nodeClass->getBase()->setVersion("2.0.0");
 
    return nodeClass->getBase();
}
 
bool VuoCompilerMakeListNodeClass::isMakeListNodeClassName(string nodeClassName)
{
    return VuoStringUtilities::beginsWith(nodeClassName, makeListNodeClassNamePrefix);
}
 
string VuoCompilerMakeListNodeClass::getNodeClassName(unsigned long itemCount, VuoCompilerType *listType)
{
    string itemTypeStr = VuoStringUtilities::substrAfter(listType->getBase()->getModuleKey(), VuoType::listTypeNamePrefix);
    return buildNodeClassName(itemCount, itemTypeStr);
}
 
bool VuoCompilerMakeListNodeClass::parseNodeClassName(string nodeClassName, unsigned long &itemCount, string &itemTypeName)
{
    string itemCountAndType = VuoStringUtilities::substrAfter(nodeClassName, makeListNodeClassNamePrefix);
    size_t dotPos = itemCountAndType.find(".");
    if (dotPos == string::npos || dotPos == 0 || dotPos == itemCountAndType.length() - 1)
        return false;
 
    string itemCountStr = itemCountAndType.substr(0, dotPos);
    itemCount = atol(itemCountStr.c_str());
    itemTypeName = itemCountAndType.substr(dotPos + 1);
    return true;
}
 
string VuoCompilerMakeListNodeClass::buildNodeClassName(unsigned long itemCount, string itemTypeName)
{
    ostringstream oss;
    oss << itemCount;
    string itemCountStr = oss.str();
 
    return makeListNodeClassNamePrefix + itemCountStr + "." + itemTypeName;
}
 
unsigned long VuoCompilerMakeListNodeClass::getItemCount(void)
{
    return itemCount;
}
 
VuoCompilerType * VuoCompilerMakeListNodeClass::getListType(void)
{
    return listType;
}
 
VuoType * VuoCompilerMakeListNodeClass::getOriginalPortType(VuoPortClass *portClass)
{
    if (portClass->getPortType() != VuoPortClass::dataAndEventPort)
        return NULL;
 
    string typeName = VuoGenericType::createGenericTypeName(1);
    return new VuoGenericType(typeName, vector<string>());
}
 
string VuoCompilerMakeListNodeClass::getOriginalGenericNodeClassName(void)
{
    return "vuo.list.make";
}
 
string VuoCompilerMakeListNodeClass::getOriginalGenericNodeClassDescription(void)
{
    return makeListNodeClassDescription;
}
 
VuoNodeSet * VuoCompilerMakeListNodeClass::getOriginalGenericNodeSet(void)
{
    return NULL;
}
 
string VuoCompilerMakeListNodeClass::createUnspecializedNodeClassName(set<VuoPortClass *> portClassesToUnspecialize)
{
    bool foundDataAndEvent = false;
    for (set<VuoPortClass *>::iterator i = portClassesToUnspecialize.begin(); i != portClassesToUnspecialize.end(); ++i)
        if ((*i)->getPortType() == VuoPortClass::dataAndEventPort)
            foundDataAndEvent = true;
 
    if (! foundDataAndEvent)
        return getBase()->getClassName();
 
    return buildNodeClassName(itemCount, VuoGenericType::createGenericTypeName(1));
}
 
string VuoCompilerMakeListNodeClass::createSpecializedNodeClassNameWithReplacement(string genericTypeName, string specializedTypeName)
{
    unsigned long itemCount = 0;
    string itemTypeName;
    parseNodeClassName(getBase()->getClassName(), itemCount, itemTypeName);
 
    string specializedItemTypeName = (itemTypeName == genericTypeName ? specializedTypeName : itemTypeName);
    return buildNodeClassName(itemCount, specializedItemTypeName);
}