コード例 #1
0
ファイル: helloworld.c プロジェクト: thias42/dLabPro
INT16 CHelloworld_GetClassInfo(SWord* lpClassWord)
{
	if (!lpClassWord) return NOT_EXEC;
	dlp_memset(lpClassWord,0,sizeof(SWord));

	lpClassWord->nWordType          = WL_TYPE_FACTORY;
	lpClassWord->nFlags             = CS_AUTOACTIVATE;

#ifdef __cplusplus

	lpClassWord->ex.fct.lpfFactory  = (LP_FACTORY_PROC)CHelloworld::CreateInstance;
	lpClassWord->ex.fct.lpfInstall  = CHelloworld::InstallProc;

#else /* #ifdef __DLP_CSCOPE */

	lpClassWord->ex.fct.lpfFactory  = (LP_FACTORY_PROC)CHelloworld_CreateInstance;
	lpClassWord->ex.fct.lpfInstall  = CHelloworld_InstallProc;

#endif /* #ifdef __DLP_CSCOPE */

	lpClassWord->ex.fct.lpProject   = "helloworld";
	lpClassWord->ex.fct.lpBaseClass = "-";
	lpClassWord->lpComment          = "Simple example for a dLabPro class";
	lpClassWord->ex.fct.lpAutoname  = "";
	lpClassWord->ex.fct.lpCname     = "CHelloworld";
	lpClassWord->ex.fct.lpAuthor    = "m.eichner";

	dlp_strcpy(lpClassWord->lpName             ,"Helloworld");
	dlp_strcpy(lpClassWord->lpObsname          ,"");
	dlp_strcpy(lpClassWord->ex.fct.version.no  ,"1.00 SLC22");

	return O_K;
}
コード例 #2
0
ファイル: file.c プロジェクト: thias42/dLabPro
INT16 CDlpFile_GetClassInfo(SWord* lpClassWord)
{
	if (!lpClassWord) return NOT_EXEC;
	dlp_memset(lpClassWord,0,sizeof(SWord));

	lpClassWord->nWordType          = WL_TYPE_FACTORY;
	lpClassWord->nFlags             = CS_AUTOINSTANCE;

#ifdef __cplusplus

	lpClassWord->ex.fct.lpfFactory  = (LP_FACTORY_PROC)CDlpFile::CreateInstance;
	lpClassWord->ex.fct.lpfInstall  = CDlpFile::InstallProc;

#else /* #ifdef __DLP_CSCOPE */

	lpClassWord->ex.fct.lpfFactory  = (LP_FACTORY_PROC)CDlpFile_CreateInstance;
	lpClassWord->ex.fct.lpfInstall  = CDlpFile_InstallProc;

#endif /* #ifdef __DLP_CSCOPE */

	lpClassWord->ex.fct.lpProject   = "file";
	lpClassWord->ex.fct.lpBaseClass = "-";
	lpClassWord->lpComment          = "File list processor and import/export filters";
	lpClassWord->ex.fct.lpAutoname  = "stdfile";
	lpClassWord->ex.fct.lpCname     = "CDlpFile";
	lpClassWord->ex.fct.lpAuthor    = "M. Wolff, M. Eichner and M. Cuevas";

	dlp_strcpy(lpClassWord->lpName             ,"file");
	dlp_strcpy(lpClassWord->lpObsname          ,"");
	dlp_strcpy(lpClassWord->ex.fct.version.no  ,"1.1.2");

	return O_K;
}
コード例 #3
0
ファイル: fsttools.c プロジェクト: gitgun/dLabPro
INT16 CFsttools_GetClassInfo(SWord* lpClassWord)
{
    if (!lpClassWord) return NOT_EXEC;
    dlp_memset(lpClassWord,0,sizeof(SWord));

    lpClassWord->nWordType          = WL_TYPE_FACTORY;
    lpClassWord->nFlags             = CS_AUTOACTIVATE;

#ifdef __cplusplus

    lpClassWord->ex.fct.lpfFactory  = (LP_FACTORY_PROC)CFsttools::CreateInstance;
    lpClassWord->ex.fct.lpfInstall  = CFsttools::InstallProc;

#else /* #ifdef __DLP_CSCOPE */

    lpClassWord->ex.fct.lpfFactory  = (LP_FACTORY_PROC)CFsttools_CreateInstance;
    lpClassWord->ex.fct.lpfInstall  = CFsttools_InstallProc;

#endif /* #ifdef __DLP_CSCOPE */

    lpClassWord->ex.fct.lpProject   = "fsttools";
    lpClassWord->ex.fct.lpBaseClass = "-";
    lpClassWord->lpComment          = "Tools for FST modification";
    lpClassWord->ex.fct.lpAutoname  = "";
    lpClassWord->ex.fct.lpCname     = "CFsttools";
    lpClassWord->ex.fct.lpAuthor    = "frank.duckhorn";

    dlp_strcpy(lpClassWord->lpName             ,"fsttools");
    dlp_strcpy(lpClassWord->lpObsname          ,"");
    dlp_strcpy(lpClassWord->ex.fct.version.no  ,"1.00 DLC22");

    return O_K;
}
コード例 #4
0
ファイル: fvrtools.c プロジェクト: gitgun/dLabPro
INT16 CFvrtools_GetClassInfo(SWord* lpClassWord)
{
	if (!lpClassWord) return NOT_EXEC;
	dlp_memset(lpClassWord,0,sizeof(SWord));

	lpClassWord->nWordType          = WL_TYPE_FACTORY;
	lpClassWord->nFlags             = CS_SINGLETON;

#ifdef __cplusplus

	lpClassWord->ex.fct.lpfFactory  = (LP_FACTORY_PROC)CFvrtools::CreateInstance;
	lpClassWord->ex.fct.lpfInstall  = CFvrtools::InstallProc;

#else /* #ifdef __DLP_CSCOPE */

	lpClassWord->ex.fct.lpfFactory  = (LP_FACTORY_PROC)CFvrtools_CreateInstance;
	lpClassWord->ex.fct.lpfInstall  = CFvrtools_InstallProc;

#endif /* #ifdef __DLP_CSCOPE */

	lpClassWord->ex.fct.lpProject   = "fvrtools";
	lpClassWord->ex.fct.lpBaseClass = "-";
	lpClassWord->lpComment          = "FST-based feature-value relation processing tools";
	lpClassWord->ex.fct.lpAutoname  = "";
	lpClassWord->ex.fct.lpCname     = "CFvrtools";
	lpClassWord->ex.fct.lpAuthor    = "Matthias Wolff, Werner Meyer";

	dlp_strcpy(lpClassWord->lpName             ,"fvrtools");
	dlp_strcpy(lpClassWord->lpObsname          ,"");
	dlp_strcpy(lpClassWord->ex.fct.version.no  ,"1.0.0");

	return O_K;
}
コード例 #5
0
ファイル: dlpobject.c プロジェクト: gitgun/dLabPro
/**
 * Base class implementation of the class information function.
 * The base class implementation does nothing.
 *
 * @param lpWord Pointer to a SWord structure which will receive the
 *               information
 * @return O_K if successful, an error code otherwise
 */
INT16 CDlpObject_GetClassInfo(SWord* lpClassWord)
{
  if (!lpClassWord) return NOT_EXEC;
  dlp_memset(lpClassWord,0,sizeof(SWord));

  lpClassWord->nWordType          = WL_TYPE_FACTORY;
  lpClassWord->nFlags             = CS_AUTOACTIVATE;

#ifdef __cplusplus

  lpClassWord->ex.fct.lpfFactory  = (LP_FACTORY_PROC)CDlpObject::CreateInstance;
  lpClassWord->ex.fct.lpfInstall  = CDlpObject::InstallProc;

#else /* #ifdef __cplusplus */

  lpClassWord->ex.fct.lpfFactory  = (LP_FACTORY_PROC)CDlpObject_CreateInstance;
  lpClassWord->ex.fct.lpfInstall  = CDlpObject_InstallProc;

#endif /* #ifdef __cplusplus */

  lpClassWord->ex.fct.lpProject   = "dlpobject";
  lpClassWord->ex.fct.lpBaseClass = "-";
  lpClassWord->lpComment          = "Generic object";
  lpClassWord->ex.fct.lpAutoname  = "";
  lpClassWord->ex.fct.lpCname     = "CDlpObject";
  lpClassWord->ex.fct.lpAuthor    = "Matthias Wolff";

  dlp_strcpy(lpClassWord->lpName             ,"object");
  dlp_strcpy(lpClassWord->lpObsname          ,"");
  dlp_strcpy(lpClassWord->ex.fct.version.no  ,"2.5.1");

  return O_K;
}
コード例 #6
0
ファイル: dlpo_stat.c プロジェクト: gitgun/dLabPro
char* CDlpObject_GetFQName(CDlpObject* _this, char* lpName, BOOL bForceArray)
{
  char        lpBuf1[255];
  char        lpBuf2[255];
  SWord*      lpWord;
  CDlpObject* lpInst = _this;

  if (!_this)
  {
    dlp_strcpy(lpName,"(null)");
    return lpName;
  }

  lpBuf2[0]='\0';

  if (!_this->m_lpContainer) dlp_strcpy(lpName,_this->m_lpInstanceName);
  else
  {
    lpWord = _this->m_lpContainer;
    while (TRUE)
    {
      /* Do no include interpreter instance name */
      if (dlp_strcmp(lpWord->lpContainer->m_lpClassName,"itp")==0) break;

      if (lpWord->nWordType==WL_TYPE_FIELD &&
          lpWord->ex.fld.nType==T_INSTANCE &&
          (lpWord->ex.fld.nArrlen!=1 || bForceArray))
      {
        /* Seek instance in array */
        INT32 i = 0;

        for (i=0; i<lpWord->ex.fld.nArrlen; i++)
          if (((CDlpObject**)lpWord->lpData)[i] == lpInst)
            break;

        if (i<lpWord->ex.fld.nArrlen)
          sprintf(lpBuf1,".%s[%ld]%s",lpWord->lpName,(long)i,lpBuf2);
        else
          /* MWX 2002-01-16:
             This is an error actually, but what should be done here ???? --> */
          sprintf(lpBuf1,".%s%s",lpWord->lpName,lpBuf2);
          /* <-- */
      }
      else sprintf(lpBuf1,".%s%s",lpWord->lpName,lpBuf2);
      strcpy(lpBuf2,lpBuf1);

      lpInst = (CDlpObject*)lpWord->lpContainer;
      DLPASSERT(lpInst); /* Word must belong to an instance! */
      if (!lpInst->m_lpContainer) break; /* No parent --> stop */
      lpWord = lpInst->m_lpContainer;
    }
    if (lpBuf2[0] == '.') dlp_memmove(lpBuf2,&lpBuf2[1],dlp_strlen(lpBuf2));
    if (strlen(lpBuf2)>0)  sprintf(lpName,"%s.%s",lpInst->m_lpInstanceName,lpBuf2);
    else                  strcpy(lpName,lpInst->m_lpInstanceName);
  }

  return lpName;
}
コード例 #7
0
ファイル: prc_impl.cpp プロジェクト: gitgun/dLabPro
/*
 * Manual page at process.def
 */
INT16 CGEN_PUBLIC CProcess::Status()
{
  CData* d;
  char   s[L_INPUTLINE];
  INT32   i;

  printf("\n"); dlp_fprint_x_line(stdout,'-',dlp_maxprintcols());               // Protocol
  printf("\n   Status of instance");                                            // Protocol
  printf("\n   process %s",BASEINST(_this)->m_lpInstanceName);                  // Protocol
  printf("\n"); dlp_fprint_x_line(stdout,'-',dlp_maxprintcols());               // Protocol
  printf("\n   State       : 0x%04X",m_nState);                                 // Protocol
  if (m_nState!=0)                                                              // In any but the maiden state
  {                                                                             // >>
    BOOL b = 0;                                                                 //   Comma flag
    printf(" (");                                                               //   Protocol
    if (m_nState&PRC_DATASENT    ) { if(b) printf(", "); printf("data sent"    ); b=1; }//...
    if (m_nState&PRC_RUNNING     ) { if(b) printf(", "); printf("running"      ); b=1; }//...
    if (m_nState&PRC_COMPLETE    ) { if(b) printf(", "); printf("complete"     ); b=1; }//...
    if (m_nState&PRC_KILLED      ) { if(b) printf(", "); printf("killed"       ); b=1; }//...
    if (m_nState&PRC_DATARECEIVED) { if(b) printf(", "); printf("data received"); b=1; }//...
    printf(")");                                                                //   Protocol
  }                                                                             // <<
  printf("\n   Return value: %ld",(long)m_nRetVal  );                           // Protocol
  if (dlp_strlen(m_psTmpFile)) printf("\n   Temp. files : %s*",m_psTmpFile);    // Protocol
  dlp_strcpy(s,m_psCmdLine); dlp_strreplace(s,m_psTmpFile,"<tmpfile>");         // Abbreviate command line
  if (dlp_strlen(m_psCmdLine)) printf("\n   Command line: %s" ,s);              // Protocol

  // Show transferred data                                                      // ------------------------------------
  if (m_iDto)                                                                   // Have data transfer object
  {                                                                             // >>
    printf("\n"); dlp_fprint_x_line(stdout,'-',dlp_maxprintcols());             //   Protocol
    printf("\n   Transferred data");                                            //   Protocol
    d = (CData*)CDlpObject_FindInstanceWord(m_iDto,PRC_S_IDSIGN,NULL);          //   Get signature table
    printf("\n   - function  : %s",(char*)CData_XAddr(d,0,0));                  //   Protocol (job function name)
    for (i=1; i<CData_GetNRecs(d); i++)                                         //   Loop over function arguemnts
      printf("\n   %13s %s",i==1?"- arguments :":"",(char*)CData_XAddr(d,i,0)); //     Protocol (job function arg.)
    d = (CData*)CDlpObject_FindInstanceWord(m_iDto,PRC_S_IDGLOB,NULL);          //   Get list of global instances
    if (d)                                                                      //   Have one
      for (i=0; i<CData_GetNRecs(d); i++)                                       //     Loop over entries
        printf("\n   %13s %-8s %s",i==0?"- globals   :":"",                     //       Protocol (global instance)
          (char*)CData_XAddr(d,i,0),(char*)CData_XAddr(d,i,1));                 //       |
    printf("\n"); dlp_fprint_x_line(stdout,'-',dlp_maxprintcols());             //   Protocol
    printf("\n   Transferred program");                                         //   Protocol
    for (i=0; dlp_strlen(__sSlaveScript[i]); i++)                               //   Loop over slave script lines
    {                                                                           //   >>
      dlp_strcpy(s,__sSlaveScript[i]);                                          //     Get a line
      if (strstr(s,"##"))*(strstr(s,"##"))='\0';                                //     Truncate at comment
      printf("\n     (%02ld) %s",i,dlp_strtrimright(s));                        //     Protocol (script line)
    }                                                                           //   <<
  }                                                                             // <<

  printf("\n"); dlp_fprint_x_line(stdout,'-',dlp_maxprintcols()); printf("\n"); // Protocol
  return O_K;                                                                   // All done
}
コード例 #8
0
ファイル: cgen_cmd.cpp プロジェクト: gitgun/dLabPro
INT16 CGEN_PROTECTED CCgen::OnLpath()
{
  char lpName[L_INPUTLINE+1];
  GetNextDefToken(lpName);
  if (!dlp_strlen(lpName)) ERRORRET(ERR_EXPECTAFTER,"name","LPATH:",0,NOT_EXEC);

  switch(m_nCreating)
  {
  case CR_PROJECT: {
    if (m_nAncestor) return O_K;
    else             dlp_convert_name(CN_XLATPATH,m_lpsLPath,lpName);
    break;}
  case CR_ERROR:
    return IERROR(this,ERR_INVALSUBKEY,"ERROR:","LPATH:",0);
  case CR_FIELD:
    return IERROR(this,ERR_INVALSUBKEY,"FIELD:","LPATH:",0);
  case CR_OPTION:
    return IERROR(this,ERR_INVALSUBKEY,"OPTION:","LPATH:",0);
  case CR_METHOD:
    return IERROR(this,ERR_INVALSUBKEY,"METHOD:","LPATH:",0);
  case CR_NOTE:
    return IERROR(this,ERR_INVALSUBKEY,"NOTE:","LPATH:",0);
  case CR_ICLS: {
    SCGIcl* s = m_lpCreatingIcl; DLPASSERT(s);
    dlp_strcpy(s->lpLPath,lpName);
    break; }
  default:
    return IERROR(this,ERR_EXPGLOBALKEY,"LPATH:",0,0);
  }

  return O_K;
}
コード例 #9
0
ファイル: cgen_cmd.cpp プロジェクト: gitgun/dLabPro
INT16 CGEN_PROTECTED CCgen::OnHfile()
{
  char lpName[L_INPUTLINE+1];
  GetNextDefToken(lpName);
  if (!dlp_strlen(lpName)) ERRORRET(ERR_EXPECTAFTER,"name","HFILE:",0,NOT_EXEC);

  switch(m_nCreating)
  {
  case CR_PROJECT:
    return IERROR(this,ERR_INVALSUBKEY,"PROJECT:","HFILE:",0);
  case CR_ERROR:
    return IERROR(this,ERR_INVALSUBKEY,"ERROR:","HFILE:",0);
  case CR_FIELD:
    return IERROR(this,ERR_INVALSUBKEY,"FIELD:","HFILE:",0);
  case CR_OPTION:
    return IERROR(this,ERR_INVALSUBKEY,"OPTION:","HFILE:",0);
  case CR_METHOD:
    return IERROR(this,ERR_INVALSUBKEY,"METHOD:","HFILE:",0);
  case CR_NOTE:
    return IERROR(this,ERR_INVALSUBKEY,"NOTE:","HFILE:",0);
  case CR_ICLS   : {
    SCGIcl* s = m_lpCreatingIcl; DLPASSERT(s);
    dlp_strcpy(s->lpHFile,lpName);
    break; }
  default:
    return IERROR(this,ERR_EXPGLOBALKEY,"HFILE:",0,0);
  }

  return O_K;
}
コード例 #10
0
ファイル: cgen_cmd.cpp プロジェクト: gitgun/dLabPro
INT16 CGEN_PROTECTED CCgen::OnMain()
{
  char lpsProjectname[L_INPUTLINE+1];
  GetNextDefToken(lpsProjectname);
  if (m_nAncestor > 0) return O_K;

  if (!dlp_strlen(lpsProjectname))
	return IERROR(this,ERR_EXPECTAFTER,"name","MAIN:",0);
    
  if (m_bAppend)
  {
    if (dlp_strncmp(m_lpsProject,lpsProjectname,dlp_strlen(lpsProjectname)) != 0 || !m_bMainProject)
    {
      IERROR(this,ERR_APPEND,"MAIN:",lpsProjectname,0);
      if (!dlp_strlen(m_lpsProject)) EXIT(ERR_EXPPROJECT,"/append MAIN:",0,0);
      return NOT_EXEC;
    }
  }

  // Set project code
  SetCreating(CR_PROJECT,NULL);
  m_bMainProject = TRUE;
  dlp_strcpy(m_lpsProject,lpsProjectname);  

  return O_K;
}
コード例 #11
0
ファイル: fwtproc.cpp プロジェクト: gitgun/dLabPro
CFWTproc::CFWTproc(const char* lpInstanceName, BOOL bCallVirtual) : inherited(lpInstanceName,0)
{
    DEBUGMSG(-1,"CFWTproc::CFWTproc; (bCallVirtual=%d)",(int)bCallVirtual,0,0);
    dlp_strcpy(m_lpClassName,"FWTproc");
    dlp_strcpy(m_lpObsoleteName,"");
    dlp_strcpy(m_lpProjectName,"FWTproc");
    dlp_strcpy(m_version.no,"1.0");
    dlp_strcpy(m_version.date,"");
    m_nClStyle = CS_AUTOACTIVATE;

    if (bCallVirtual)
    {
        DLPASSERT(OK(AutoRegisterWords()));
        Init(TRUE);
    }
}
コード例 #12
0
ファイル: fsttools.c プロジェクト: gitgun/dLabPro
void CFsttools_Constructor(CFsttools* _this, const char* lpInstanceName, BOOL bCallVirtual)
{
    DEBUGMSG(-1,"CFsttools_Constructor; (bCallVirtual=%d)",(int)bCallVirtual,0,0);

#ifndef __cplusplus

    /* Register instance */
    dlp_xalloc_register_object('J',_this,1,sizeof(CFsttools),
                               __FILE__,__LINE__,"fsttools",lpInstanceName);

    /* Create base instance */
    _this->m_lpBaseInstance = calloc(1,sizeof(CDlpObject));
    CDlpObject_Constructor(_this->m_lpBaseInstance,lpInstanceName,FALSE);

    /* Override virtual member functions */
    _this->m_lpBaseInstance->AutoRegisterWords = CFsttools_AutoRegisterWords;
    _this->m_lpBaseInstance->Reset             = CFsttools_Reset;
    _this->m_lpBaseInstance->Init              = CFsttools_Init;
    _this->m_lpBaseInstance->Serialize         = CFsttools_Serialize;
    _this->m_lpBaseInstance->SerializeXml      = CFsttools_SerializeXml;
    _this->m_lpBaseInstance->Deserialize       = CFsttools_Deserialize;
    _this->m_lpBaseInstance->DeserializeXml    = CFsttools_DeserializeXml;
    _this->m_lpBaseInstance->Copy              = CFsttools_Copy;
    _this->m_lpBaseInstance->ClassProc         = CFsttools_ClassProc;
    _this->m_lpBaseInstance->GetInstanceInfo   = CFsttools_GetInstanceInfo;
    _this->m_lpBaseInstance->IsKindOf          = CFsttools_IsKindOf;
    _this->m_lpBaseInstance->Destructor        = CFsttools_Destructor;
    _this->m_lpBaseInstance->ResetAllOptions   = CFsttools_ResetAllOptions;

    /* Override pointer to derived instance */
    _this->m_lpBaseInstance->m_lpDerivedInstance = _this;

#endif /* #ifndef __cplusplus */

    dlp_strcpy(BASEINST(_this)->m_lpClassName,"fsttools");
    dlp_strcpy(BASEINST(_this)->m_lpObsoleteName,"");
    dlp_strcpy(BASEINST(_this)->m_lpProjectName,"fsttools");
    dlp_strcpy(BASEINST(_this)->m_version.no,"1.00 DLC22");
    dlp_strcpy(BASEINST(_this)->m_version.date,"");
    BASEINST(_this)->m_nClStyle = CS_AUTOACTIVATE;

    if (bCallVirtual)
    {
        DLPASSERT(OK(INVOKE_VIRTUAL_0(AutoRegisterWords)));
        INVOKE_VIRTUAL_1(Init,TRUE);
    }
}
コード例 #13
0
ファイル: cgen_cmd.cpp プロジェクト: gitgun/dLabPro
INT16 CGEN_PROTECTED CCgen::OnMsvcFlags()
{
  const char* lpFlags = GetRestOfDefLine();
  if (m_nAncestor) return O_K;
  if (!dlp_strlen(lpFlags))
    ERRORRET(ERR_EXPECTAFTER,"compiler options","MSVCFLAGS:",0,NOT_EXEC);
  dlp_strcpy(m_lpsMsvcFlags,lpFlags);
  return O_K;
}
コード例 #14
0
ファイル: cgen_cmd.cpp プロジェクト: gitgun/dLabPro
INT16 CGEN_PROTECTED CCgen::OnClass()
{
  char lpClassname[L_INPUTLINE+1];
  GetNextDefToken(lpClassname);

  if (m_nAncestor > 1) return O_K;

  if (!dlp_strlen(lpClassname))
    return IERROR(this,ERR_EXPECTAFTER,"name","CLASS:",0);

  char bad = 0;
  if (!m_bNoIdcheck)
    IF_NOK(dlp_is_valid_id(IDT_CLASS,lpClassname,&bad)) 
      IERROR(this,ERR_BADIDCHAR,lpClassname,bad,0);
    
  if (m_nAncestor == 1) dlp_strcpy(m_lpsDlcParent,lpClassname);
  else                  dlp_strcpy(m_lpsClass,lpClassname);  
  return O_K;
}
コード例 #15
0
ファイル: cgen_cmd.cpp プロジェクト: gitgun/dLabPro
INT16 CGEN_PROTECTED CCgen::OnAuthor()
{
  const char* lpAuthor = GetRestOfDefLine();

  if (m_nAncestor) return O_K;

  if (!dlp_strlen(lpAuthor)) ERRORRET(ERR_EXPECTAFTER,"author name","AUTHOR:",0,NOT_EXEC);

  dlp_strcpy(m_lpsAuthor,lpAuthor);  
  return O_K;
}
コード例 #16
0
ファイル: prc_impl.cpp プロジェクト: gitgun/dLabPro
/*
 * Manual page at process.def
 */
INT32 CGEN_PUBLIC CProcess::Start()
{
  const SMic* pMic    = NULL;                                                   // Method invocation context of Start()
  CFunction*  iCaller = NULL;                                                   // Function calling Start()
  CFunction*  iFnc    = NULL;                                                   // Process function
  StkItm*     pStkItm = NULL;                                                   // Stack item
  INT32       nArgs   = 0;                                                      // Number of process function arguments

  // Validate and initialize                                                    // ------------------------------------
  if (m_nState!=0)                                                              // Not virginal
    return IERROR(this,PRC_CANTSTART,"multiple starts not allowed",0,0);        //   Forget it!
  if (!(pMic = CDlpObject_MicGet(_this))) return -1;                            // Get method invocation context
  iCaller = (CFunction*)CDlpObject_OfKind("function",pMic->iCaller);            // Get calling CFunction
  if (!iCaller) return -1;                                                      // Must be a function!

  // Initialize process                                                         // ------------------------------------
  sprintf(m_psTmpFile,"%s%ld",dlp_tempnam(NULL,"~dLabPro#process#"),(long)dlp_time());// Initialize temp. file name prefix

  // Marshal arguments                                                          // ------------------------------------
  if (!(pStkItm=iCaller->StackGet(0))) return IERROR(this,PRC_TOOFEWARGS,0,0,0);// Get stack top
  if (pStkItm->nType==T_INSTANCE)                                               // Stack top is an instance
    iFnc = (CFunction*)CDlpObject_OfKind("function",pStkItm->val.i);            //   Get function to be called
  if (iFnc)                                                                     // This process is a function call
  {                                                                             // >>
    IFIELD_RESET(CDlpObject,"dto");                                             //   Create data transfer object
    nArgs = CData_GetNRecs(iFnc->m_idArg);                                      //   Get number of function arguments
    Marshal(m_iDto,iCaller,nArgs);                                              //   Marshal arguments for transfer
  }                                                                             // <<
  else                                                                          // This process is a program call
    dlp_strcpy(m_psCmdLine,iCaller->PopString(0));                              //   Get program command line

#ifdef USE_FORK
  if (iFnc)                                                                     // This process is a function call
  {                                                                             // >>
    m_hPid=fork();                                                              //   Fork the process
    if(m_hPid>0){                                                               //   Parent process >>
      m_nState |= PRC_DATASENT;                                                 //     Remember data have been sent
      m_nState |= PRC_RUNNING;                                                  //     Set running flag
      m_hThread = 0;                                                            //     Clear thread handle
      return O_K;                                                               //     Everything is fine
    }                                                                           //   <<
    if(m_hPid==0) return DoJobFork(iCaller,iFnc);                               //   The child process runs the function
    return IERROR(this,PRC_CANTSTART,"fork() failed",0,0);                      //   On error (fid<0) we return
  }                                                                             // <<
#endif
  // Start job in watcher thread                                                // ------------------------------------
  m_hPid = 0;                                                                   // Reset process id
  SendData();                                                                   // Send transfer data
  m_hThread = dlp_create_thread(DoJob,this);                                    // Do the job and watch it

  return O_K;                                                                   // Yo!
}
コード例 #17
0
ファイル: prc_impl.cpp プロジェクト: gitgun/dLabPro
/**
 * Packs a stack item into the data transfer object <code>iDto</code>. If the
 * stack item is an instance, the function will create a copy in
 * <code>iDto</code>. If the stack item is a boolean, numeric or string value,
 * the function will create a variable holding that value in <code>iDto</code>.
 *
 * @param iDto
 *          the data transfer object (must not be <code>NULL</code>)
 * @param idSign
 *          the signature table (may be <code>NULL</code>, if not
 *          <code>NULL</code> the item will be added to the signature)
 * @param pStkItm
 *          the stack item to pack (see documentation of <code>CFunction</code>)
 * @param psName
 *          the object name (if <code>NULL</code> or empty, a default name will
 *          be used   )
 */
void CGEN_PROTECTED CProcess::Pack
(
  CDlpObject* iDto,
  CData*      idSign,
  StkItm*     pStkItm,
  const char* psName
)
{
  CDlpObject* iDst = 0;                                                         // Packed instance
  INT32        nArg = -1;                                                        // Argument index in signature
  char        sBuf[L_NAMES];                                                    // Packed instance name buffer

  // Validate and initialize                                                    // ------------------------------------
  if (!iDto   ) return;                                                         // Need data transfer object!
  if (!pStkItm) return;                                                         // Need stack item!
  dlp_strcpy(sBuf,psName);                                                      // Copy custom instance name
  if (idSign) nArg = CData_AddRecs(idSign,1,10);                                // Add element to signature

  // Pack                                                                       // ------------------------------------
  if (pStkItm->nType==T_INSTANCE && pStkItm->val.i!=NULL)                       // Pack an instance
  {                                                                             // >>
    CDlpObject* iSrc = pStkItm->val.i;                                          //   Get pointer to instance
    if (dlp_strlen(sBuf)==0) dlp_strcpy(sBuf,iSrc->m_lpInstanceName);           //   No custom name -> use inst. name
    iDst = CDlpObject_Instantiate(iDto,iSrc->m_lpClassName,sBuf,FALSE);         //   Created packed instance
    iDst->Copy(iSrc);                                                           //   Copy content
  }                                                                             // <<
  else                                                                          // Pack a boolean, number or string
  {                                                                             // >>
    if (dlp_strlen(sBuf)==0) sprintf(sBuf,"arg%ld",(long)nArg);                 //   No custom name -> make a name
    iDst = CDlpObject_Instantiate(iDto,"var",sBuf,FALSE);                       //   Create a variable to pack into
    switch (pStkItm->nType)                                                     //   Branch for variable type
    {                                                                           //   |
    case T_BOOL   : ((CVar*)iDst)->Bset(pStkItm->val.b);   break;               //   Pack a boolean
    case T_COMPLEX: ((CVar*)iDst)->Vset(pStkItm->val.n);   break;               //   Pack a number
    case T_STRING : ((CVar*)iDst)->Sset(pStkItm->val.s);   break;               //   Pack a string
    }                                                                           //   |
  }                                                                             // <<
  if (idSign) CData_Sstore(idSign,sBuf,nArg,0);                                 // Write signature
}
コード例 #18
0
ファイル: fwtproc.cpp プロジェクト: gitgun/dLabPro
INT16 CFWTproc::GetClassInfo(SWord* lpClassWord)
{
    if (!lpClassWord) return NOT_EXEC;
    dlp_memset(lpClassWord,0,sizeof(SWord));

    lpClassWord->nWordType          = WL_TYPE_FACTORY;
    lpClassWord->nFlags             = CS_AUTOACTIVATE;
    lpClassWord->ex.fct.lpfFactory  = (LP_FACTORY_PROC)CFWTproc::CreateInstance;
    lpClassWord->ex.fct.lpfInstall  = CFWTproc::InstallProc;
    lpClassWord->ex.fct.lpProject   = "FWTproc";
    lpClassWord->ex.fct.lpBaseClass = "FBAproc";
    lpClassWord->lpComment          = "Base class for fast discrete wavelet transformation.";
    lpClassWord->ex.fct.lpAutoname  = "";
    lpClassWord->ex.fct.lpCname     = "CFWTproc";
    lpClassWord->ex.fct.lpAuthor    = "Soeren Wittenberg";

    dlp_strcpy(lpClassWord->lpName             ,"FWTproc");
    dlp_strcpy(lpClassWord->lpObsname          ,"");
    dlp_strcpy(lpClassWord->ex.fct.version.no  ,"1.0");

    return O_K;
}
コード例 #19
0
ファイル: pmproc.cpp プロジェクト: gitgun/dLabPro
INT16 CPMproc::GetClassInfo(SWord* lpClassWord)
{
    if (!lpClassWord) return NOT_EXEC;
    dlp_memset(lpClassWord,0,sizeof(SWord));

    lpClassWord->nWordType          = WL_TYPE_FACTORY;
    lpClassWord->nFlags             = CS_AUTOACTIVATE;
    lpClassWord->ex.fct.lpfFactory  = (LP_FACTORY_PROC)CPMproc::CreateInstance;
    lpClassWord->ex.fct.lpfInstall  = CPMproc::InstallProc;
    lpClassWord->ex.fct.lpProject   = "PMproc";
    lpClassWord->ex.fct.lpBaseClass = "-";
    lpClassWord->lpComment          = "Base class for pitch calculation.";
    lpClassWord->ex.fct.lpAutoname  = "";
    lpClassWord->ex.fct.lpCname     = "CPMproc";
    lpClassWord->ex.fct.lpAuthor    = "Guntram Strecha";

    dlp_strcpy(lpClassWord->lpName             ,"PMproc");
    dlp_strcpy(lpClassWord->lpObsname          ,"");
    dlp_strcpy(lpClassWord->ex.fct.version.no  ,"1.0 DLP");

    return O_K;
}
コード例 #20
0
ファイル: fftproc.cpp プロジェクト: thias42/dLabPro
INT16 CFFTproc::GetClassInfo(SWord* lpClassWord)
{
	if (!lpClassWord) return NOT_EXEC;
	dlp_memset(lpClassWord,0,sizeof(SWord));

	lpClassWord->nWordType          = WL_TYPE_FACTORY;
	lpClassWord->nFlags             = CS_AUTOACTIVATE;
	lpClassWord->ex.fct.lpfFactory  = (LP_FACTORY_PROC)CFFTproc::CreateInstance;
	lpClassWord->ex.fct.lpfInstall  = CFFTproc::InstallProc;
	lpClassWord->ex.fct.lpProject   = "FFTproc";
	lpClassWord->ex.fct.lpBaseClass = "FBAproc";
	lpClassWord->lpComment          = "FFT class based on FBAproc";
	lpClassWord->ex.fct.lpAutoname  = "";
	lpClassWord->ex.fct.lpCname     = "CFFTproc";
	lpClassWord->ex.fct.lpAuthor    = "Matthias Eichner";

	dlp_strcpy(lpClassWord->lpName             ,"FFTproc");
	dlp_strcpy(lpClassWord->lpObsname          ,"");
	dlp_strcpy(lpClassWord->ex.fct.version.no  ,"1.0 DLP");

	return O_K;
}
コード例 #21
0
ファイル: dgen.cpp プロジェクト: gitgun/dLabPro
INT16 CDgen::GetClassInfo(SWord* lpClassWord)
{
	if (!lpClassWord) return NOT_EXEC;
	dlp_memset(lpClassWord,0,sizeof(SWord));

	lpClassWord->nWordType          = WL_TYPE_FACTORY;
	lpClassWord->nFlags             = CS_AUTOACTIVATE;
	lpClassWord->ex.fct.lpfFactory  = (LP_FACTORY_PROC)CDgen::CreateInstance;
	lpClassWord->ex.fct.lpfInstall  = CDgen::InstallProc;
	lpClassWord->ex.fct.lpProject   = "dgen";
	lpClassWord->ex.fct.lpBaseClass = "-";
	lpClassWord->lpComment          = "Document parser and generator";
	lpClassWord->ex.fct.lpAutoname  = "";
	lpClassWord->ex.fct.lpCname     = "CDgen";
	lpClassWord->ex.fct.lpAuthor    = "Matthias Wolff";

	dlp_strcpy(lpClassWord->lpName             ,"DGen");
	dlp_strcpy(lpClassWord->lpObsname          ,"");
	dlp_strcpy(lpClassWord->ex.fct.version.no  ,"1.0.1");

	return O_K;
}
コード例 #22
0
ファイル: lpcproc.cpp プロジェクト: thias42/dLabPro
INT16 CLPCproc::GetClassInfo(SWord* lpClassWord)
{
	if (!lpClassWord) return NOT_EXEC;
	dlp_memset(lpClassWord,0,sizeof(SWord));

	lpClassWord->nWordType          = WL_TYPE_FACTORY;
	lpClassWord->nFlags             = CS_AUTOACTIVATE;
	lpClassWord->ex.fct.lpfFactory  = (LP_FACTORY_PROC)CLPCproc::CreateInstance;
	lpClassWord->ex.fct.lpfInstall  = CLPCproc::InstallProc;
	lpClassWord->ex.fct.lpProject   = "LPCproc";
	lpClassWord->ex.fct.lpBaseClass = "FBAproc";
	lpClassWord->lpComment          = "Linear prediction coding (LPC) analysis and synthesis";
	lpClassWord->ex.fct.lpAutoname  = "";
	lpClassWord->ex.fct.lpCname     = "CLPCproc";
	lpClassWord->ex.fct.lpAuthor    = "Guntram Strecha";

	dlp_strcpy(lpClassWord->lpName             ,"LPCproc");
	dlp_strcpy(lpClassWord->lpObsname          ,"");
	dlp_strcpy(lpClassWord->ex.fct.version.no  ,"1.0 DLP");

	return O_K;
}
コード例 #23
0
ファイル: hfaproc.cpp プロジェクト: thias42/dLabPro
INT16 CHFAproc::GetClassInfo(SWord* lpClassWord)
{
	if (!lpClassWord) return NOT_EXEC;
	dlp_memset(lpClassWord,0,sizeof(SWord));

	lpClassWord->nWordType          = WL_TYPE_FACTORY;
	lpClassWord->nFlags             = CS_AUTOACTIVATE;
	lpClassWord->ex.fct.lpfFactory  = (LP_FACTORY_PROC)CHFAproc::CreateInstance;
	lpClassWord->ex.fct.lpfInstall  = CHFAproc::InstallProc;
	lpClassWord->ex.fct.lpProject   = "HFAproc";
	lpClassWord->ex.fct.lpBaseClass = "FBAproc";
	lpClassWord->lpComment          = "Harmonicity based feature analysis";
	lpClassWord->ex.fct.lpAutoname  = "";
	lpClassWord->ex.fct.lpCname     = "CHFAproc";
	lpClassWord->ex.fct.lpAuthor    = "Rico Petrick, Mike Lorenz";

	dlp_strcpy(lpClassWord->lpName             ,"HFAproc");
	dlp_strcpy(lpClassWord->lpObsname          ,"");
	dlp_strcpy(lpClassWord->ex.fct.version.no  ,"1.0");

	return O_K;
}
コード例 #24
0
ファイル: cgen_cmd.cpp プロジェクト: gitgun/dLabPro
INT16 CGEN_PROTECTED CCgen::OnAutoinstance()
{
  char lpAutoname[L_INPUTLINE+1];
  GetNextDefToken(lpAutoname);

  if (m_bMainProject)
    return IERROR(this,ERR_INVALKEY,"AUTOINSTANCE:","MAIN:",0);
  if (m_nAncestor) return O_K;

  if (!dlp_strlen(lpAutoname))
    return IERROR(this,ERR_EXPECTIDAFTER,"name","AUTOINSTANCE:",0);

  dlp_strcpy(m_lpsAutoname,lpAutoname);
  m_nCSXXX |= CS_AUTOINSTANCE;

    return O_K;
}
コード例 #25
0
ファイル: data_ini.c プロジェクト: gitgun/dLabPro
/**
 * Get data initializer '{ ... }' from command line and store into token list
 * lpsInit.
 * <h3>Note</h3>
 * <p>You must setup the method invocation context <code>m_lpMic</code> (see 
 * <a href="dlpinst.html"><code class="link">CDlpInstance</code></a>) before
 * calling this method. Otherwise it will do noting.</p>
 *
 * @param lpsInit Pointer to character buffer to store initializer in. The
 *                tokens will be separated by nulls '\0', opening and closing
 *                curly braces will not be included! The token list will be
 *                terminated with a double null "\0\0".
 * @param nLen    Maximal number of characters to place on lpsInit (including
 *                the terminal double null)
 * @param bForce  If TRUE the method does not seek for the opening curly brace
 *                but starts reading initializers until it encounters a closing
 *                curly brace '}'. A leading opening curly brace will, however,
 *                be tolerated. If FALSE the method <i>expects</i> an opening
 *                curly brace and does not read any initializers if no leading
 *                opening brace is found.
 * @return The number of initializers read
 */
INT32 CGEN_PROTECTED CData_ReadInitializer
(
  CData* _this,
  char*  lpsInit,
  INT32   nLen,
  BOOL   bForce
)
{
  const char* lpsToken;                                                         /* Current token                     */
  INT32        nCnt;                                                             /* Token counter                     */
  INT32        nPos;                                                             /* Position in output buffer         */
  BOOL        bStor;                                                            /* Store next token                  */

  /* Initialize */                                                              /* --------------------------------- */
  if (!CDlpObject_MicGet(BASEINST(_this))) return 0;                            /* Need invocation context           */
  if (!lpsInit) return 0;                                                       /* Need output buffer                */
  dlp_memset(lpsInit,0,nLen);                                                   /* Clear output buffer               */

  /* Do initializers follow? */                                                 /* --------------------------------- */
  lpsToken = MIC_NEXTTOKEN_FORCE;                                                /* Ruthlessly get next token         */
  if (!lpsToken || dlp_strcmp(lpsToken,"{")!=0)                                 /* No or not the "{" token           */
  {                                                                             /* >>                                */
    if (bForce) IERROR(_this,DATA_NOTFOUND,"Constant initializer ","'{'",0);    /*   If there should be some-> error */
    if (lpsToken) MIC_REFUSETOKEN;                                              /*   Wrong token -> push it back     */
    return 0;                                                                   /*   Now get out'a here              */
  }                                                                             /* <<                                */

  /* Get 'em tokens */                                                          /* --------------------------------- */
  for (nCnt=0,nPos=0,bStor=TRUE; ; nCnt++)                                      /* Infinitely ...                    */
  {                                                                             /* >>                                */
    lpsToken = MIC_NEXTTOKEN_FORCE;                                             /*   Ruthlessly get next token       */
    if (!lpsToken) return IERROR(_this,DATA_HERESCAN,"}",0,0);                  /*   No more tokens -> forget it     */
    if (dlp_strcmp(lpsToken,"}")==0) break;                                     /*   End token -> get out'a here     */

    if (nLen<nPos+(INT32)dlp_strlen(lpsToken)+2) bStor = FALSE;                  /*   Cannot store more tokens :(     */
    if (!bStor) continue;                                                       /*   Ignore ALL following tokens     */

    dlp_strcpy(&lpsInit[nPos],lpsToken);                                        /*   Store token                     */
    nPos+=(INT32)dlp_strlen(&lpsInit[nPos])+1;                                   /*   Set next token pointer          */
  }                                                                             /* <<                                */

  return nCnt;                                                                  /* Return number of tokens read      */
}
コード例 #26
0
ファイル: dlp_file.c プロジェクト: thias42/dLabPro
/**
 * Changes the current working directory. If <code>bCreate</code> is
 * <code>TRUE</code> and the directory does not exists, <code>dlp_chdir</code>
 * will create the directory. <code>dlp_chdir</code> is capable of creating a
 * tree of non-existing directories at once.
 *
 * @param lpsDirname Destination directory
 * @param bCreate    Create directory if not exists
 * @return 0 if successful, an error code (or -1) if not sucessful
 */
INT16 dlp_chdir(const char* lpsDirname, BOOL bCreate)
{
  char  lpsDir[L_PATH];
  char* tx;
  INT16 nError;

  if (dlp_strlen(lpsDirname)==0) return 0;
  nError = (INT16)chdir(lpsDirname);
  if (nError == 0 || !bCreate) return nError;

  /* Try to create path */
  dlp_memset(lpsDir,0,L_PATH);
  dlp_strcpy(lpsDir,lpsDirname);

  /* Change into the furthest existing directory */
  tx = &lpsDir[dlp_strlen(lpsDir)-1];
  while (tx != lpsDir)
  {
    while (tx!=lpsDir && *tx != '\\' && *tx != '/') tx--;
    if (tx!=lpsDir) *tx=0;
    if (chdir(lpsDir) == 0) break;
  }
  if (tx!=lpsDir) tx++;

  /* Create remaining sub directories */
  while (tx[1])
  {
#if (defined __MSOS || defined __WIN32)
    nError = (INT16)mkdir(tx);
#else
    nError = (INT16)mkdir(tx,0xFFFF);
#endif
    if (nError) return nError;
    nError = (INT16)chdir(tx);
    if (nError) return nError;
    while (*tx++);
  }

  /* Should have worked... */
  return 0;
}
コード例 #27
0
ファイル: file.c プロジェクト: thias42/dLabPro
INT16 CDlpFile_Reset(CDlpObject* __this, BOOL bResetMembers)
{
	GET_THIS_VIRTUAL_RV(CDlpFile,NOT_EXEC);
	DEBUGMSG(-1,"CDlpFile_Reset; (bResetMembers=%d)",(int)bResetMembers,0,0);
	{
	/*{{CGEN_RESETCODE */

  CData* idFlistData;
  char   lpsB1[255];
  char   lpsB2[255];
  char   lpsB3[ 32];
  char   lpsB4[255];

	if (_this->m_idFlistData==NULL) IFIELD_RESET(CData,"flist_data");
  IFIELD_RESET(CData,"recfile");
  dlp_strcpy(lpsB1,_this->m_lpsFlist);
  dlp_strcpy(lpsB2,_this->m_lpsPath);
  dlp_strcpy(lpsB3,_this->m_lpsExt);
  dlp_strcpy(lpsB4,_this->m_lpsSep);
  idFlistData = AS(CData,_this->m_idFlistData);
  _this->m_idFlistData = NULL;

  RESET;

  _this->m_idFlistData = BASEINST(idFlistData);
  dlp_strcpy(_this->m_lpsFlist,lpsB1);
  dlp_strcpy(_this->m_lpsPath ,lpsB2);
  dlp_strcpy(_this->m_lpsExt  ,lpsB3);
  dlp_strcpy(_this->m_lpsSep  ,lpsB4);
  _this->m_nLen = CData_GetNRecs(AS(CData,_this->m_idFlistData));

	/*}}CGEN_RESETCODE */
	}

	return O_K;
}
コード例 #28
0
ファイル: dlp_file.c プロジェクト: thias42/dLabPro
/**
 * Create an absolute or full path name for the specified relative path name.
 *
 * @param lpsAbsPath
 *          Pointer to a buffer to be filled with the absolute path.
 * @param lpsRelPath
 *          Pointer to a null-terminated string containing the relative path.
 * @param nMaxLen
 *          Maximum length of the absolute path name buffer
 *          (<code>lpsAbsPath</code>).
 * @return <code>lpsAbsPath</code> if successful, <code>NULL</code> in case of
 *         errors.
 */
char* dlp_fullpath(char* lpsAbsPath, const char* lpsRelPath, INT32 nMaxLen)
{
  char        lpsCwd [L_PATH+1];                                                /* Saved current working directory   */
  char        lpsDir [L_PATH+1];                                                /* Directory part of lpsRelPath      */
  char        lpsFile[L_PATH+1];                                                /* Filename part of lpsRelPath       */
  struct stat filestat;                                                         /* File status struct                */
  if (!lpsAbsPath || nMaxLen<=0) return NULL;                                   /* No buffer, no service!            */
  *lpsAbsPath='\0';                                                             /* Initialize result to empty string */
  dlp_splitpath(lpsRelPath,lpsDir,lpsFile);                                     /* Split relative path               */
  if (!dlp_strlen(lpsDir)) dlp_strcpy(lpsDir,".");                              /* No directory -> use current one   */
  if(getcwd(lpsCwd,L_PATH)==NULL) return NULL;                                  /* Save current working directory    */
  if (dlp_chdir(lpsDir,FALSE)!=0) { dlp_chdir(lpsCwd,FALSE); return NULL;  }    /* Change to relative directory ...  */
  if(getcwd(lpsDir,L_PATH)==NULL) return NULL;                                  /* ... and determine its full path   */
  dlp_chdir(lpsCwd,FALSE);                                                      /* Change back to saved working dir. */
  if (nMaxLen<(INT32)(dlp_strlen(lpsDir)+dlp_strlen(lpsFile)+2)) return NULL;   /* Check return buffer size          */
  sprintf(lpsAbsPath,"%s%c%s",lpsDir,C_DIR,lpsFile);                            /* Create absolute path              */
#ifdef _WINDOWS                                                                 /* -- WINDOZE -->                    */
  dlp_strreplace(lpsAbsPath,"\\","/");                                          /* Replace backslashes by slashes    */
/*  dlp_strlwr(lpsAbsPath); */                                                    /* Convert to lower case             */
#endif                                                                          /* <--                               */
  if (stat(lpsAbsPath,&filestat)!=0) return NULL;                               /* Check file status (must exist)    */
  return lpsAbsPath;                                                            /* Return pointer to buffer          */
}
コード例 #29
0
ファイル: prc_impl.cpp プロジェクト: gitgun/dLabPro
INT32 CGEN_PRIVATE CProcess::DoJobFork(CFunction *iCaller, CFunction *iFnc)
{
  CData*      idSign = NULL;                                                    // Signature table in iDto
  CDlpObject* iArg   = NULL;                                                    // Argument Object
  INT32       nArg   = -1;                                                      // Argument loop counter
  char        sArg[L_NAMES];                                                    // Current argument name
  char        lpsCmd[256];                                                      // String buffer

  // Initialize                                                                 // ------------------------------------
  idSign = (CData*)CDlpObject_OfKind("data",                                    // Get signature table
    CDlpObject_FindInstance(m_iDto,PRC_S_IDSIGN));                              // |

  // Push arguments on Stack                                                    // ------------------------------------
  for (nArg=CData_GetNRecs(idSign)-1; nArg>0; nArg--)                           // Loop over signature table
  {                                                                             // >>
    dlp_strcpy(sArg,CData_Sfetch(idSign,nArg,0));                               //   Get argument name
    iArg = CDlpObject_FindInstance(m_iDto,sArg);                                //   Find argument in iDto
    if (CDlpObject_OfKind("var",iArg)) switch(AS(CVar,iArg)->m_nType){          //   Primitve data types >>
      case T_BOOL   : iCaller->PushLogic (AS(CVar,iArg)->m_bBVal); break;       //     Push bool
      case T_COMPLEX: iCaller->PushNumber(AS(CVar,iArg)->m_nNVal); break;       //     Push number
      case T_STRING : iCaller->PushString(AS(CVar,iArg)->m_lpsSVal); break;     //     Push string
      default: iCaller->PushNumber(CMPLX(0.)); break;                           //     Default: push something
    }else iCaller->PushInstance(iArg);                                          //   Push instances
  }                                                                             // <<

  // Post commands in queue                                                     // ------------------------------------
  iCaller->PostCommand(CData_Sfetch(idSign,0,0),NULL,-1,FALSE);                 // Put in queue: run the function
  snprintf(lpsCmd,255,"%s.dto %s -marshal_retval;",                             // Put in queue: save return value
      this->m_lpInstanceName,this->m_lpInstanceName);                           // |
  iCaller->PostCommand(lpsCmd,NULL,-1,FALSE);                                   // |
  snprintf(lpsCmd,255,"\"%s.xml\" %s.dto /xml /zip -save;",                     // Put in queue: save data transfer object
      m_psTmpFile,this->m_lpInstanceName);                                      // |
  iCaller->PostCommand(lpsCmd,NULL,-1,FALSE);                                   // |
  iCaller->PostCommand("quit;",NULL,-1,FALSE);                                  // Put in queue: Quit the client process
  return O_K;                                                                   // Ok, run the queue
}
コード例 #30
0
ファイル: prc_impl.cpp プロジェクト: gitgun/dLabPro
/**
 * Unpacks the data transfer object <code>iDto</code> into <code>iCaller</code>.
 */
void CGEN_PROTECTED CProcess::Unmarshal(CDlpObject* iDto, CFunction* iCaller)
{
  CData*      idSign = NULL;                                                    // Signature table in iDto
  CDlpObject* iSrc   = NULL;                                                    // Source object
  CDlpObject* iDst   = NULL;                                                    // Destination object
  INT32        nArg   = -1;                                                      // Argument loop counter
  char        sArg[L_NAMES];                                                    // Current argument name

  // Initialize                                                                 // ------------------------------------
  idSign = (CData*)CDlpObject_OfKind("data",                                    // Get signature table
    CDlpObject_FindInstance(iDto,PRC_S_IDSIGN));                                // |

  // Unmarshal arguments                                                        // ------------------------------------
  for (nArg=1; nArg<CData_GetNRecs(idSign); nArg++)                             // Loop over signature table
  {                                                                             // >>
    dlp_strcpy(sArg,CData_Sfetch(idSign,nArg,0));                               //   Get argument name
    iSrc = CDlpObject_FindInstance(iDto,sArg);                                  //   Find argument in iDto
    if (CDlpObject_OfKind("var",iSrc)) continue;                                //   Ignore primitve data types
    iDst = CDlpObject_FindInstance(iCaller,sArg);                               //   Find argument in iCaller
    if (!iDst) continue;                                                        //   Not there -> nothing to do
    iDst->Copy(iSrc);                                                           //   Copy unmarshaled arg. to caller
  }                                                                             // <<

  // Unmarshal return value                                                     // ------------------------------------
  iSrc = CDlpObject_FindInstance(iDto,PRC_S_RETV);                              // Find return value in iDto
  if (CDlpObject_OfKind("var",iSrc))                                            // Return value is a primitive
    switch (((CVar*)iSrc)->m_nType)                                             //   Branch for type
    {                                                                           //   |
    case T_BOOL   : iCaller->PushLogic (((CVar*)iSrc)->m_bBVal  ); break;       //   Push a boolean
    case T_DOUBLE :                                                             //   Push a number
    case T_COMPLEX: iCaller->PushNumber(((CVar*)iSrc)->m_nNVal  ); break;       //   Push a complex number
    case T_STRING : iCaller->PushString(((CVar*)iSrc)->m_lpsSVal); break;       //   Push a string
    }                                                                           //   |
  else if (iSrc)                                                                // Return value is an instance
    iCaller->PushInstance(iSrc);                                                //   Push it
}