Merge remote-tracking branch 'origin/master' into yasp 80/11480/2
Antoine ELIAS [Mon, 13 May 2013 14:58:22 +0000 (16:58 +0200)]
Conflicts:
scilab/modules/core/src/fortran/core_f.vfproj
scilab/modules/elementary_functions/tests/nonreg_tests/bug_426.tst
scilab/modules/fileio/src/c/mget.c
scilab/modules/fileio/src/c/mput.c
scilab/modules/overloading/macros/%hm_matrix.sci
scilab/modules/overloading/macros/%i_b_s.sci
scilab/modules/overloading/macros/%s_b_i.sci
scilab/modules/overloading/macros/%s_b_s.sci
scilab/modules/overloading/macros/generic_i_h.sci
scilab/modules/ui_data/src/cpp/UpdateBrowseVar.cpp

Change-Id: I1328764eed1ff7c55cec518f93f9d26be56b0eb5

15 files changed:
1  2 
scilab/modules/core/src/fortran/core_f.vfproj
scilab/modules/differential_equations/macros/integrate.sci
scilab/modules/elementary_functions/tests/nonreg_tests/bug_426.dia.ref
scilab/modules/fileio/src/cpp/mget.cpp
scilab/modules/fileio/src/cpp/mput.cpp
scilab/modules/graphics/sci_gateway/c/sci_set.c
scilab/modules/gui/Makefile.am
scilab/modules/gui/Makefile.in
scilab/modules/overloading/macros/%s_v_r.sci
scilab/modules/overloading/macros/%s_v_s.sci
scilab/modules/overloading/macros/generic_i_h.sci
scilab/modules/randlib/src/c/clcg4.c
scilab/modules/randlib/src/c/randlib.vcxproj
scilab/modules/ui_data/src/cpp/UpdateBrowseVar.cpp
scilab/test/good/typeof.sci

index 677eec0,0000000..a654903
mode 100644,000000..100644
--- /dev/null
@@@ -1,262 -1,0 +1,262 @@@
 +/*
 + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 + * Copyright (C) 2007 - INRIA
 + * ...
 + *
 + * This file must be used under the terms of the CeCILL.
 + * This source file is licensed as described in the file COPYING, which
 + * you should have received as part of this distribution.  The terms
 + * are also available at
 + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 + *
 + */
 +/*--------------------------------------------------------------------------*/
 +#include <string.h>
 +#include "filemanager.hxx"
 +
 +extern "C"
 +{
 +#ifndef _MSC_VER
 +#include <stdint.h>
 +#else
 +#define int32_t long
 +#define uint32_t unsigned long
 +#endif
 +#include "mget.h"
 +#include "filesmanagement.h"
 +#include "sciprint.h"
 +#include "islittleendian.h"
 +#include "convert_tools.h"
 +#include "localization.h"
 +#include "charEncoding.h"
 +#include "MALLOC.h"
 +}
 +/*--------------------------------------------------------------------------*/
 +/* =================================================
 +* reads data and store them without type conversion
 +* =================================================*/
 +/*--------------------------------------------------------------------------*/
 +#define MGET_CHAR_NC(Type)                                    \
 +  {                                                           \
 +    Type *val = (Type *) res ;                                        \
 +    items=(int)fread(val,sizeof(Type),n,fa);                  \
 +  }
 +
 +/*--------------------------------------------------------------------------*/
 +#define MGET_NC(Type) {                                               \
 +    Type *val = (Type *) res ;                                        \
 +    if (swap) {                                                       \
 +      items=0;                                                        \
 +      for ( i=0; i< n; i++)  {                                        \
 +      unsigned long long tmp;                                 \
 +      items+=(int)fread(&tmp,sizeof(Type),1,fa);              \
 +      swap_generic((char *)&tmp,(char *)val, sizeof(Type));   \
 +      val++;                                                  \
 +      }                                                               \
 +    }                                                         \
 +    else items=(int)fread(val,sizeof(Type),n,fa);             \
 +  }
 +/*--------------------------------------------------------------------------*/
 +#define MGET_GEN_NC(NumType,cf)                                       \
 +  {                                                           \
 +    switch (cf) {                                             \
 +    case ' ':                                                 \
 +      MGET_NC(NumType);break;                                 \
 +    case 'b':                                                 \
 +      swap = (islittleendian()==1)? 1:0;                      \
 +    MGET_NC(NumType); break;                                  \
 +    case 'l':                                                 \
 +      swap = (islittleendian()==1) ? 0:1;                     \
 +    MGET_NC(NumType);  break;                                 \
 +    default:                                                  \
 +      sciprint(_("%s: Wrong value for input argument #%d: '%s' or '%s' or '%s' expected.\n"),"mget",4," ","b","l"); \
 +      *ierr=1; return;                                                \
 +    }                                                         \
 +}
 +/*--------------------------------------------------------------------------*/
 +void C2F(mgetnc)(int* fd, void* res, int* n1, char* type, int* ierr)
 +{
 +    char c1;
 +    char c2;
 +    int i;
 +    int items   = *n1;
 +    int n       = *n1;
 +    FILE* fa; // used in MGET_GEN_NC => MGET_NC
 +    File* pFile = FileManager::getFile(*fd);
 +
 +    *ierr = 0;
 +
 +    if (pFile == NULL || (fa = pFile->getFiledesc()) == NULL)
 +    {
 +        sciprint(_("%s: No input file associated to logical unit %d.\n"), "mget", *fd);
 +        *ierr = 3;
 +        return;
 +    }
 +
 +    c1 = (strlen(type) > 1) ? type[1] : ' ';
 +    c2 = (strlen(type) > 2) ? type[2] : ' ';
 +
 +    int swap = pFile->getFileSwap(); // used in MGET_GEN_NC => MGET_NC
 +
 +    switch (type[0])
 +    {
 +        case 'i' :
 +            MGET_GEN_NC(int, c1);
 +            break;
 +        case 'l' :
-             MGET_GEN_NC(int32_t, c1);
++            MGET_GEN_NC(long long, c1);
 +            break;
 +        case 's' :
 +            MGET_GEN_NC(short, c1);
 +            break;
 +        case 'c' :
 +            MGET_CHAR_NC(char);
 +            break;
 +        case 'd' :
 +            MGET_GEN_NC(double, c1);
 +            break;
 +        case 'f' :
 +            MGET_GEN_NC(float, c1);
 +            break;
 +        case 'u' :
 +            switch (c1)
 +            {
 +                case 'i' :
 +                    MGET_GEN_NC(unsigned int, c2);
 +                    break;
 +                case 'l' :
-                     MGET_GEN_NC(uint32_t, c2);
++                    MGET_GEN_NC(unsigned long long, c2);
 +                    break;
 +                case 's' :
 +                    MGET_GEN_NC(unsigned short, c2);
 +                    break;
 +                case ' ' :
 +                    MGET_GEN_NC(unsigned int, ' ');
 +                    break;
 +                case 'c' :
 +                    MGET_CHAR_NC(unsigned char);
 +                    break;
 +                default :
 +                    *ierr = 1;
 +                    return;
 +            }
 +            break;
 +        default :
 +            *ierr = 1;
 +            return;
 +    }
 +
 +    if (items != n)
 +    {
 +        *ierr = -items - 1 ;
 +        // sciprint("Read %d out of\n",items,n);
 +    }
 +
 +    return;
 +}
 +/*--------------------------------------------------------------------------*/
 +/* =================================================
 +* reads data and store them in double
 +* =================================================*/
 +
 +/* conversion macro  */
 +#define CONVGD(Type)                          \
 +  {                                           \
 +    Type *val = (Type *) res ;                        \
 +    for ( i = items-1 ; i >=0 ; i--)          \
 +      res[i] = val[i];                                \
 +  }
 +/*--------------------------------------------------------------------------*/
 +#define MGET_GEN(NumType,cf)  MGET_GEN_NC(NumType,cf); CONVGD(NumType);
 +#define MGET_CHAR(NumType)    MGET_CHAR_NC(NumType);   CONVGD(NumType);
 +/*--------------------------------------------------------------------------*/
 +/* reads data and store them in double  */
 +void mget2(FILE *fa, int swap, double *res, int n, char *type, int *ierr)
 +{
 +    char c1, c2;
 +    int i, items = n;
 +    *ierr = 0;
 +    c1 = ( strlen(type) > 1) ? type[1] : ' ';
 +    c2 = ( strlen(type) > 2) ? type[2] : ' ';
 +    switch ( type[0] )
 +    {
 +        case 'i' :
 +            MGET_GEN(int, c1);
 +            break;
 +        case 'l' :
-             MGET_GEN(int32_t, c1);
++            MGET_GEN(long long, c1);
 +            break;
 +        case 's' :
 +            MGET_GEN(short, c1);
 +            break;
 +        case 'c' :
 +            MGET_CHAR(char);
 +            break;
 +        case 'd' :
 +            MGET_GEN(double, c1);
 +            break;
 +        case 'f' :
 +            MGET_GEN(float, c1);
 +            break;
 +        case 'u' :
 +            switch ( c1 )
 +            {
 +                case 'i' :
 +                    MGET_GEN(unsigned int, c2);
 +                    break;
 +                case 'l' :
-                     MGET_GEN(uint32_t, c2);
++                    MGET_GEN(unsigned long long, c2);
 +                    break;
 +                case 's' :
 +                    MGET_GEN(unsigned short, c2);
 +                    break;
 +                case ' ' :
 +                    MGET_GEN(unsigned int, ' ');
 +                    break;
 +                case 'c' :
 +                    MGET_CHAR(unsigned char);
 +                    break;
 +                default :
 +                    *ierr = 1;
 +                    return;
 +                    break;
 +            }
 +            break;
 +        default :
 +            *ierr = 1;
 +            return ;
 +    }
 +    if ( items != n )
 +    {
 +        *ierr = -(items) - 1 ;
 +        /** sciprint("Read %d out of\n",items,n); **/
 +    }
 +    return;
 +}
 +/*--------------------------------------------------------------------------*/
 +void C2F(mget) (int *fd, double *res, int *n, char *type, int *ierr)
 +{
 +    *ierr = 0;
 +    if (strlen(type) == 0)
 +    {
 +        sciprint(_("%s: Wrong size for input argument #%d: Non-empty string expected.\n"), "mget", 4, type);
 +        *ierr = 2;
 +        return;
 +    }
 +
 +    File* pFile = FileManager::getFile(*fd);
 +    if (pFile && pFile->getFiledesc())
 +    {
 +        mget2(pFile->getFiledesc(), pFile->getFileSwap(), res, *n, type, ierr);
 +        if (*ierr > 0)
 +        {
 +            sciprint(_("%s: Wrong value for input argument #%d: Format not recognized.\n"), "mget", 4);
 +        }
 +    }
 +    else
 +    {
 +        sciprint(_("%s: No input file associated to logical unit %d.\n"), "mget", *fd);
 +        *ierr = 3;
 +    }
 +}
 +/*--------------------------------------------------------------------------*/
index da41c4c,0000000..c387da2
mode 100644,000000..100644
--- /dev/null
@@@ -1,280 -1,0 +1,280 @@@
 +/*
 + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 + * Copyright (C) 2007 - INRIA
 + * ...
 + *
 + * This file must be used under the terms of the CeCILL.
 + * This source file is licensed as described in the file COPYING, which
 + * you should have received as part of this distribution.  The terms
 + * are also available at
 + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 + *
 + */
 +/*--------------------------------------------------------------------------*/
 +#include <string.h>
 +#include "filemanager.hxx"
 +extern "C"
 +{
 +#ifndef _MSC_VER
 +#include <stdint.h>
 +#else
 +#define int32_t long
 +#define uint32_t unsigned long
 +#endif
 +#include "mput.h"
 +#include "filesmanagement.h"
 +#include "sciprint.h"
 +#include "islittleendian.h"
 +#include "convert_tools.h"
 +#include "localization.h"
 +#include "sci_warning.h"
 +#include "charEncoding.h"
 +}
 +/*--------------------------------------------------------------------------*/
 +/*===============================================
 + * function to write data without type conversion
 + *===============================================*/
 +#define MPUT_CHAR_NC(Type)                    \
 +  {                                           \
 +    Type *val = (Type *) res ;                        \
 +    fwrite(val,sizeof(Type),n,fa);            \
 +  }
 +/*--------------------------------------------------------------------------*/
 +#define MPUT_NC(Type) {                                       \
 +    Type *val = (Type *) res ;                                \
 +    if ( swap) {                                      \
 +      unsigned long long temp;                                \
 +      for ( i=0; i< n; i++) {                         \
 +      swap_generic((char *)val,(char *)&temp, sizeof(Type));  \
 +        val++;                                                \
 +      fwrite(&temp,sizeof(Type),1,fa);                \
 +      }                                                       \
 +    }                                                 \
 +    else fwrite(val,sizeof(Type),n,fa);                       \
 +  }
 +/*--------------------------------------------------------------------------*/
 +#define MPUT_GEN_NC(Type,cf)                                          \
 +  switch ( cf )                                                               \
 +    {                                                                 \
 +    case ' ':                                                         \
 +      MPUT_NC(Type); break;                                           \
 +    case 'b':                                                         \
 +      swap = (islittleendian()==1) ? 1 : 0;                           \
 +    MPUT_NC(Type); break;                                             \
 +    case 'l':                                                         \
 +      swap = (islittleendian()==1) ? 0 : 1;                           \
 +    MPUT_NC(Type); break;                                             \
 +    default:                                                          \
 +      sciprint(_("%s: Wrong value for input argument #%d (%s): '%s' or '%s' or '%s' expected.\n"),"mput",4,type," ","b","l"); \
 +      *ierr=1;return;                                                 \
 +    }
 +/*--------------------------------------------------------------------------*/
 +/* write data without convertion (res is supposed to have type type) */
 +void C2F(mputnc) (int *fd, void * res, int *n1, char *type, int *ierr)
 +{
 +    char c1, c2;
 +    int i, n;
 +    FILE *fa;
 +    n = *n1;
 +    *ierr = 0;
 +    if ((fa = GetFileOpenedInScilab(*fd)) == NULL)
 +    {
 +        if ( getWarningMode() )
 +        {
 +            sciprint(_("%s: No input file associated to logical unit %d.\n"), "mput", *fd);
 +        }
 +        *ierr = 3;
 +        return;
 +    }
 +    int swap = GetSwapStatus(*fd);
 +
 +    c1 = ( strlen(type) > 1) ? type[1] : ' ';
 +    c2 = ( strlen(type) > 2) ? type[2] : ' ';
 +    switch ( type[0] )
 +    {
 +        case 'i' :
 +            MPUT_GEN_NC(int, c1);
 +            break;
 +        case 'l' :
-             MPUT_GEN_NC(int32_t, c1);
++            MPUT_GEN_NC(long long, c1);
 +            break;
 +        case 's' :
 +            MPUT_GEN_NC(short, c1);
 +            break;
 +        case 'c' :
 +            MPUT_CHAR_NC(char) ;
 +            break;
 +        case 'd' :
 +            MPUT_GEN_NC(double, c1);
 +            break;
 +        case 'f' :
 +            MPUT_GEN_NC(float, c1);
 +            break;
 +        case 'u' :
 +            switch ( c1 )
 +            {
 +                case 'i' :
 +                    MPUT_GEN_NC(unsigned int, c2);
 +                    break;
 +                case 'l' :
-                     MPUT_GEN_NC(uint32_t, c2);
++                    MPUT_GEN_NC(unsigned long long, c2);
 +                    break;
 +                case 's' :
 +                    MPUT_GEN_NC(unsigned short, c2);
 +                    break;
 +                case ' ' :
 +                    MPUT_GEN_NC(unsigned int, ' ');
 +                    break;
 +                case 'c' :
 +                    MPUT_CHAR_NC(unsigned char);
 +                    break;
 +                default :
 +                    *ierr = 1;
 +                    return ;
 +            }
 +            break;
 +        default :
 +            *ierr = 1;
 +            break;
 +    }
 +}
 +/*--------------------------------------------------------------------------*/
 +/*================================================
 + * function to write data stored in double
 + *================================================*/
 +/** used for char **/
 +#define MPUT_CHAR(Type) {                     \
 +    for ( i=0; i< n; i++) {                   \
 +      Type  val = (char) *res++;              \
 +      fwrite(&val,sizeof(Type),1,fa);         \
 +    }                                         \
 +  }
 +/*--------------------------------------------------------------------------*/
 +/** write in a machine independant way : i.e data
 +    is swaped if necessary to output little-endian
 +    data **/
 +
 +#define MPUT(Type) {                                          \
 +    Type val;                                                 \
 +    for ( i=0; i< n; i++) {                                   \
 +      val =(Type)res[i];                                      \
 +      if ( swap) {                                            \
 +      unsigned long long temp;                                \
 +      swap_generic((char *)&val,(char *)&temp, sizeof(Type)); \
 +      fwrite(&temp,sizeof(Type),1,fa);                        \
 +      }                                                               \
 +      else fwrite(&val,sizeof(Type),1,fa);                    \
 +    }                                                         \
 +  }
 +
 +/*--------------------------------------------------------------------------*/
 +/** The output mode is controlled by type[1] **/
 +#define MPUT_GEN(Type,cf)                                             \
 +  switch ( cf )                                                               \
 +    {                                                                 \
 +    case ' ':                                                         \
 +      MPUT(Type); break;                                              \
 +    case 'b':                                                         \
 +      swap = (islittleendian()==1) ? 1 : 0;                           \
 +    MPUT(Type); break;                                                        \
 +    case 'l':                                                         \
 +      swap = (islittleendian()==1) ? 0 : 1;                           \
 +    MPUT(Type); break;                                                        \
 +    default:                                                          \
 +      if ( getWarningMode() ) sciprint(_("%s: Wrong value for input argument #%d (%s): '%s' or '%s' or '%s' expected.\n"),"mput",4,type," ","b","l"); \
 +      *ierr=1;return;                                                 \
 +    }
 +/*--------------------------------------------------------------------------*/
 +void mput2 (FILE *fa, int swap, double *res, int n, char *type, int *ierr)
 +{
 +    char c1, c2;
 +    int i;
 +    *ierr = 0;
 +    c1 = ( strlen(type) > 1) ? type[1] : ' ';
 +    c2 = ( strlen(type) > 2) ? type[2] : ' ';
 +    switch ( type[0] )
 +    {
 +        case 'i' :
 +            MPUT_GEN(int, c1);
 +            break;
 +        case 'l' :
-             MPUT_GEN(int32_t, c1);
++            MPUT_GEN(long long, c1);
 +            break;
 +        case 's' :
 +            MPUT_GEN(short, c1);
 +            break;
 +        case 'c' :
 +            MPUT_CHAR(char) ;
 +            break;
 +        case 'd' :
 +            MPUT_GEN(double, c1);
 +            break;
 +        case 'f' :
 +            MPUT_GEN(float, c1);
 +            break;
 +        case 'u' :
 +            switch ( c1 )
 +            {
 +                case 'i' :
 +                    MPUT_GEN(unsigned int, c2);
 +                    break;
 +                case 'l' :
-                     MPUT_GEN(uint32_t, c2);
++                    MPUT_GEN(unsigned long long, c2);
 +                    break;
 +                case 's' :
 +                    MPUT_GEN(unsigned short, c2);
 +                    break;
 +                case ' ' :
 +                    MPUT_GEN(unsigned int, ' ');
 +                    break;
 +                case 'c' :
 +                    MPUT_CHAR(unsigned char);
 +                    break;
 +                default :
 +                    *ierr = 1;
 +                    return ;
 +            }
 +            break;
 +        default :
 +            *ierr = 1;
 +            break;
 +    }
 +}
 +/*--------------------------------------------------------------------------*/
 +void C2F(mput) (int *fd, double *res, int *n, char *type, int *ierr)
 +{
 +    *ierr = 0;
 +    if (strlen(type) == 0)
 +    {
 +        if (getWarningMode())
 +        {
 +            sciprint(_("%s: Wrong size for input argument #%d ('%s'): Non-empty string expected.\n"), "mput", 4, type);
 +        }
 +        *ierr = 2;
 +        return;
 +    }
 +
 +    File *pFile = FileManager::getFile(*fd);
 +    if (pFile && pFile->getFiledesc())
 +    {
 +        mput2(pFile->getFiledesc(), pFile->getFileSwap(), res, *n, type, ierr);
 +        if (*ierr > 0)
 +        {
 +            if (getWarningMode())
 +            {
 +                sciprint(_("%s: Wrong value for input argument #%d ('%s'): Format not recognized.\n"), "mput", 4, type);
 +            }
 +        }
 +    }
 +    else
 +    {
 +        if (getWarningMode())
 +        {
 +            sciprint(_("%s: No input file associated to logical unit %d.\n"), "mput", *fd);
 +        }
 +        *ierr = 3;
 +    }
 +}
 +/*--------------------------------------------------------------------------*/
 +
 +
Simple merge
Simple merge
@@@ -8,15 -8,15 +8,15 @@@
  // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  
  function h=%s_v_r(h1,h2)
- // %s_v_r(h1,h2) = (I+h1*h2)\h1. h1 constant h2 rational
- //!
+     // %s_v_r(h1,h2) = (I+h1*h2)\h1. h1 constant h2 rational
+     //!
  
- [m1,n1]=size(h1)
- [m2,n2]=size(h2('num'))
- if abs(n1-m2)+abs(m1-n2)<>0 then error('inconsistent dimensions'),end
- if m1*n1==1 then
-   h=h2;h('num')=h1*h2('den');h('den')=h1*h2('num')+h2('den');
- else
-   h=(eye(m1,m1)+h1*h2)\h1
- end
+     [m1,n1]=size(h1)
+     [m2,n2]=size(h2('num'))
 -    if abs(n1-m2)+abs(m1-n2)<>0 then error(msprintf(_("%s: Wrong size for input argument(s).\n'),"%s_v_r")),end
++    if abs(n1-m2)+abs(m1-n2)<>0 then error(msprintf(_("%s: Wrong size for input argument(s).\n"),"%s_v_r")),end
+     if m1*n1==1 then
+         h=h2;h('num')=h1*h2('den');h('den')=h1*h2('num')+h2('den');
+     else
+         h=(eye(m1,m1)+h1*h2)\h1
+     end
  endfunction
@@@ -8,10 -8,10 +8,10 @@@
  // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  
  function [h]=%s_v_s(h1,h2)
- // %s_v_s(h1,h2)  <=> h =(I+h1*h2)\h1 <=> h=h1/.h2
+     // %s_v_s(h1,h2)  <=> h =(I+h1*h2)\h1 <=> h=h1/.h2
  
- [m1,n1]=size(h1)
- [m2,n2]=size(h2)
- if abs(n1-m2)+abs(m1-n2)<>0 then error('inconsistent dimensions'),end
- h=(eye(m1,m1)+h1*h2)\h1
+     [m1,n1]=size(h1)
+     [m2,n2]=size(h2)
 -    if abs(n1-m2)+abs(m1-n2)<>0 then error(msprintf(_("%s: Wrong size for input argument(s).\n'),"%s_v_s")),end
++    if abs(n1-m2)+abs(m1-n2)<>0 then error(msprintf(_("%s: Wrong size for input argument(s).\n"),"%s_v_s")),end
+     h=(eye(m1,m1)+h1*h2)\h1
  endfunction
@@@ -8,62 -8,62 +8,63 @@@
  // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  
  function h=generic_i_h(i,v,h)
-   hsave=h
- //  if v==[] then error('Field property cannot be []'),end
-   if type(i)==10 then set(h,i,v),return,end
-   if type(i)<>15 then  error('Invalid path'),end
+     hsave=h
+     //  if v==[] then error('Field property cannot be []'),end
+     if type(i)==10 then set(h,i,v),return,end
+     if type(i)<>15 then  error(msprintf(_("%s: Wrong type for input argument #%d.\n"),"generic_i_h",1)),end
  
-   if and(type(i($))<>[1 2 4 8 129 15]) then
-     i($+1)=: 
-   end
-   n=lstsize(i)
-   hdl=h;hind=[]
-   for k=1:lstsize(i)// walk down in the handle tree
-     p=i(k)
-     lasthandle=hdl,
-     if type(p)==10 then
-       hdl=get(hdl,p),
-     elseif or(type(p)==[1 2 4 8 129]) then
-       hdl=hdl(p)
-     elseif type(p)==15 then
-       hdl=hdl(p(:))
-     else
-       error('Invalid path')
+     if and(type(i($))<>[1 2 4 8 129 15]) then
+         i($+1)=: 
      end
-     
-     if type(hdl)<>9 then //a leaf found
-       property=hdl
-       hdl=lasthandle
-       hind=p
-       if (k+1)==size(i) then
-           index=i($)
-       else
-         index=list(i(k+1:$))
-       end
-       break
++
+     n=lstsize(i)
+     hdl=h;hind=[]
+     for k=1:lstsize(i)// walk down in the handle tree
+         p=i(k)
+         lasthandle=hdl,
+         if type(p)==10 then
+             hdl=get(hdl,p),
+         elseif or(type(p)==[1 2 4 8 129]) then
+             hdl=hdl(p)
+         elseif type(p)==15 then
+             hdl=hdl(p(:))
+         else
+             error('Invalid path')
+         end
+         if type(hdl)<>9 then //a leaf found
+             property=hdl
+             hdl=lasthandle
+             hind=p
+             if (k+1)==size(i) then
+                 index=i($)
+             else
+                 index=list(i(k+1:$))
+             end
+             break
+         end
      end
-   end
-   if hind<>[] then // a property found
-     if type(index)==15 & and(type(property)<>[15 16 17]) then
-       property(index(:))=v
+     if hind<>[] then // a property found
+         if type(index)==15 & and(type(property)<>[15 16 17]) then
+             property(index(:))=v
+         else
+             if or(size(index)<>[-1 -1]) then
+                 property(index)=v
+             else
+                 property=v
+             end
+         end
+         if size(hdl,'*')==1 then //a single handle
+             hdl(hind)=property
+         else //mutiple handle 
+             np=size(hdl,'*')
+             for k=1:np
+                 h=hdl(k);h(hind)=property
+             end
+         end
      else
-       if or(size(index)<>[-1 -1]) then
-           property(index)=v
-       else
-           property=v
-       end
-     end
-     if size(hdl,'*')==1 then //a single handle
-       hdl(hind)=property
-     else //mutiple handle 
-       np=size(hdl,'*')
-       for k=1:np
-       h=hdl(k);h(hind)=property
-       end
-       
+         error(msprintf(_("%s: Wrong type for input argument #%d.\n"),"generic_i_h",1));
      end
-   else
-     error('Invalid path')
-   end
-  h= hsave
+     h= hsave
  endfunction
@@@ -1,10 -1,10 +1,10 @@@
  /*
-- * 
++ *
   * Copyright (C) 2010 - DIGITEO - Michael Baudin
   * Copyright (C) 2004 - Bruno Pincon
   * Copyright (C) 1998 - Terry H. Andres
   * Copyright (C) 1998 - Pierre Lecuyer
-- * 
++ *
   *  PURPOSE
   *     clcg4 generator stuff
   *
   *
   *  NOTES
   *     The original code was slightly modified by Bruno Pincon for inclusion
-- *     in Scilab. 
++ *     in Scilab.
   *
   *     list of main modifs :
   *
   *       - lot of routine 's names have changed to have some kind of
-- *         uniformity with the others generators 
++ *         uniformity with the others generators
   *
   *       - add a var is_init so that initialisation is performed inside
   *         this module (to simplify the interface). And bring modif in
   *            x_{j,n} = a_j * x_{j,n-1} mod m_j    0 <= j <= 3
   *
   *         The output with form (2) (original form in this code) :
-- *         
++ *
   *            z_n = ( sum_j  delta_j * x_{j,n} / m_j ) mod 1
   *
   *         have been changed in the form (1) :
   *
   *           z_n = ( sum_j  delta_j * x_{j,n} ) mod m_1 (then u_n = z_n / m_1)
-- *         
++ *
   *         to have some "uniformity" with all the others generators (which
   *         gives integers). Also it is better for the uin(a,b) generation
   *         to start from integers.
@@@ -61,6 -61,7 +61,7 @@@
  #include "sciprint.h"
  #include "others_generators.h"
  #include "localization.h"
 -#include "warningmode.h"
++#include "sci_warning.h"
  
  /***********************************************************************/
  /* Private part.                                                       */
  #define H   32768               /* = 2^15 : use in MultModM.           */
  
  static int aw[4], avw[4],      /*   a[j]^{2^w} et a[j]^{2^{v+w}}.     */
--a[4] = { 45991, 207707, 138556, 49689 },
--m[4] = { 2147483647, 2147483543, 2147483423, 2147483323 };
++       a[4] = { 45991, 207707, 138556, 49689 },
++              m[4] = { 2147483647, 2147483543, 2147483423, 2147483323 };
  
--static int Ig[4][Maxgen+1], Lg[4][Maxgen+1], Cg[4][Maxgen+1];
++static int Ig[4][Maxgen + 1], Lg[4][Maxgen + 1], Cg[4][Maxgen + 1];
  /* Initial seed, previous seed, and current seed. */
  
  
@@@ -87,35 -88,35 +88,75 @@@ static int MultModM (int s, int t, int 
  {
      int R, S0, S1, q, qh, rh, k;
  
--    if (s < 0)  s += M;
--    if (t < 0)  t += M;
--    if (s < H)  { S0 = s;  R = 0; }
++    if (s < 0)
++    {
++        s += M;
++    }
++    if (t < 0)
++    {
++        t += M;
++    }
++    if (s < H)
++    {
++        S0 = s;
++        R = 0;
++    }
      else
      {
--        S1 = s/H;  S0 = s - H*S1;
--        qh = M/H;  rh = M - H*qh;
++        S1 = s / H;
++        S0 = s - H * S1;
++        qh = M / H;
++        rh = M - H * qh;
          if (S1 >= H)
          {
--            S1 -= H;   k = t/qh;   R = H * (t - k*qh) - k*rh;
--            while (R < 0)  R += M;
++            S1 -= H;
++            k = t / qh;
++            R = H * (t - k * qh) - k * rh;
++            while (R < 0)
++            {
++                R += M;
++            }
++        }
++        else
++        {
++            R = 0;
          }
--        else R = 0;
          if (S1 != 0)
          {
--            q = M/S1;   k = t/q;   R -= k * (M - S1*q);
--            if (R > 0)  R -= M;
--            R += S1*(t - k*q);
--            while (R < 0)  R += M;
++            q = M / S1;
++            k = t / q;
++            R -= k * (M - S1 * q);
++            if (R > 0)
++            {
++                R -= M;
++            }
++            R += S1 * (t - k * q);
++            while (R < 0)
++            {
++                R += M;
++            }
++        }
++        k = R / qh;
++        R = H * (R - k * qh) - k * rh;
++        while (R < 0)
++        {
++            R += M;
          }
      }
      if (S0 != 0)
      {
--        q = M/S0;   k = t/q;   R -= k* (M - S0*q);
--        if (R > 0)  R -= M;
--        R += S0 * (t - k*q);
--        while (R < 0)  R += M;
++        q = M / S0;
++        k = t / q;
++        R -= k * (M - S0 * q);
++        if (R > 0)
++        {
++            R -= M;
++        }
++        R += S0 * (t - k * q);
++        while (R < 0)
++        {
++            R += M;
++        }
      }
      return R;
  }
@@@ -127,10 -128,10 +168,14 @@@ static void comp_aw_and_avw(int v, int 
      {
          aw [j] = a [j];
          for (i = 1; i <= w; i++)
++        {
              aw [j]  = MultModM (aw [j], aw [j], m[j]);
++        }
          avw [j] = aw [j];
          for (i = 1; i <= v; i++)
++        {
              avw [j] = MultModM (avw [j], avw [j], m[j]);
++        }
      }
  }
  
@@@ -151,14 -152,14 +196,18 @@@ static int verif_seeds_clcg4(double s0
  {
      /* verify that the seeds are "integers" and are in the good range */
      if ( s0 == floor(s0) && s1 == floor(s1) &&
--        s2 == floor(s2) && s3 == floor(s3) &&
--        1 <= s0  &&  s0 <= 2147483646      &&
--        1 <= s1  &&  s1 <= 2147483542      &&
--        1 <= s2  &&  s2 <= 2147483422      &&
--        1 <= s3  &&  s3 <= 2147483322 )
++            s2 == floor(s2) && s3 == floor(s3) &&
++            1 <= s0  &&  s0 <= 2147483646      &&
++            1 <= s1  &&  s1 <= 2147483542      &&
++            1 <= s2  &&  s2 <= 2147483422      &&
++            1 <= s3  &&  s3 <= 2147483322 )
++    {
          return ( 1 );
++    }
      else
++    {
          return ( 0 );
++    }
  }
  
  static void display_info_clcg4(void)
  
  int set_seed_clcg4(int g, double s0, double s1, double s2, double s3)
  {
--    if (! is_init ) {init_clcg4(v_default,w_default); is_init = 1; };
++    if (! is_init )
++    {
++        init_clcg4(v_default, w_default);
++        is_init = 1;
++    };
  
      if ( verif_seeds_clcg4(s0, s1, s2, s3) )
      {
--        Ig [0][g] = (int) s0; Ig [1][g] = (int) s1;
--        Ig [2][g] = (int) s2; Ig [3][g] = (int) s3;
++        Ig [0][g] = (int) s0;
++        Ig [1][g] = (int) s1;
++        Ig [2][g] = (int) s2;
++        Ig [3][g] = (int) s3;
          init_generator_clcg4(g, InitialSeed);
-         sciprint(_("\n=> be aware that you have may lost synchronization\n    between the virtual gen %d and the others !\n    use grand(\"setall\", s1, s2, s3, s4) if you want recover it."), g);
+         if (getWarningMode())
+         {
 -        sciprint(_("WARNING: %s\n"), _("be aware that you have may lost synchronization\n    between the virtual gen %d and the others !\n    use grand(\"setall\", s1, s2, s3, s4) if you want recover it."), g);
++            sciprint(_("WARNING: %s\n"), _("be aware that you have may lost synchronization\n    between the virtual gen %d and the others !\n    use grand(\"setall\", s1, s2, s3, s4) if you want recover it."), g);
+         }
          return ( 1 );
      }
      else
  void get_state_clcg4(int g, double s[4])
  {
      int j;
--    if (! is_init ) {init_clcg4(v_default,w_default); is_init = 1; };
--    for (j = 0; j < 4; j++)  s [j] = (double) Cg [j][g];
++    if (! is_init )
++    {
++        init_clcg4(v_default, w_default);
++        is_init = 1;
++    };
++    for (j = 0; j < 4; j++)
++    {
++        s [j] = (double) Cg [j][g];
++    }
  }
  
  void init_generator_clcg4(int g, SeedType Where)
  {
      int j;
--    if (! is_init ) {init_clcg4(v_default,w_default); is_init = 1; };
++    if (! is_init )
++    {
++        init_clcg4(v_default, w_default);
++        is_init = 1;
++    };
      for (j = 0; j < 4; j++)
      {
          switch (Where)
          {
--        case InitialSeed :
--            Lg [j][g] = Ig [j][g];   break;
--        case NewSeed :
--            Lg [j][g] = MultModM (aw [j], Lg [j][g], m [j]);   break;
--        case LastSeed :
--            break;
++            case InitialSeed :
++                Lg [j][g] = Ig [j][g];
++                break;
++            case NewSeed :
++                Lg [j][g] = MultModM (aw [j], Lg [j][g], m [j]);
++                break;
++            case LastSeed :
++                break;
          }
          Cg [j][g] = Lg [j][g];
      }
@@@ -223,13 -227,13 +294,19 @@@ void advance_state_clcg4(int g, int k
      int b[4];
      int i, j;
  
--    if (! is_init ) {init_clcg4(v_default,w_default); is_init = 1; };
++    if (! is_init )
++    {
++        init_clcg4(v_default, w_default);
++        is_init = 1;
++    };
  
      for ( j = 0 ; j < 4 ; j++ )
      {
          b[j] = a[j];
          for ( i = 1 ; i <= k ; i++ )
++        {
              b[j] = MultModM( b[j], b[j], m[j]);
++        }
          Ig[j][g] = MultModM ( b[j], Cg[j][g], m[j] );
      }
      init_generator_clcg4(g, InitialSeed);
@@@ -239,7 -243,7 +316,10 @@@ int set_initial_seed_clcg4(double s0, d
  {
      int g, j;
  
--    if (! is_init )  comp_aw_and_avw(v_default,w_default);
++    if (! is_init )
++    {
++        comp_aw_and_avw(v_default, w_default);
++    }
  
      if ( ! verif_seeds_clcg4(s0, s1, s2, s3) )
      {
      for (g = 1; g <= Maxgen; g++)
      {
          for (j = 0; j < 4; j++)
--            Ig [j][g] = MultModM (avw [j], Ig [j][g-1], m [j]);
++        {
++            Ig [j][g] = MultModM (avw [j], Ig [j][g - 1], m [j]);
++        }
          init_generator_clcg4(g, InitialSeed);
      }
      return ( 1 );
@@@ -266,35 -270,35 +348,71 @@@ unsigned int clcg4(int g
  {
      /* Modif Bruno : the generator have now the form (1) in place of (2) */
  
--    int k,s;
++    int k, s;
      double u;
  
--    if (! is_init ) {init_clcg4(v_default,w_default); is_init = 1; };
++    if (! is_init )
++    {
++        init_clcg4(v_default, w_default);
++        is_init = 1;
++    };
  
      /*  advance the 4 LCG */
--    s = Cg [0][g];  k = s / 46693;
++    s = Cg [0][g];
++    k = s / 46693;
      s = 45991 * (s - k * 46693) - k * 25884;
--    if (s < 0) s = s + 2147483647;  Cg [0][g] = s;
++    if (s < 0)
++    {
++        s = s + 2147483647;
++    }
++    Cg [0][g] = s;
  
--    s = Cg [1][g];  k = s / 10339;
++    s = Cg [1][g];
++    k = s / 10339;
      s = 207707 * (s - k * 10339) - k * 870;
--    if (s < 0) s = s + 2147483543;  Cg [1][g] = s;
++    if (s < 0)
++    {
++        s = s + 2147483543;
++    }
++    Cg [1][g] = s;
  
--    s = Cg [2][g];  k = s / 15499;
++    s = Cg [2][g];
++    k = s / 15499;
      s = 138556 * (s - k * 15499) - k * 3979;
--    if (s < 0) s = s + 2147483423;  Cg [2][g] = s;
++    if (s < 0)
++    {
++        s = s + 2147483423;
++    }
++    Cg [2][g] = s;
  
--    s = Cg [3][g];  k = s / 43218;
++    s = Cg [3][g];
++    k = s / 43218;
      s = 49689 * (s - k * 43218) - k * 24121;
--    if (s < 0) s = s + 2147483323;  Cg [3][g] = s;
++    if (s < 0)
++    {
++        s = s + 2147483323;
++    }
++    Cg [3][g] = s;
  
      /*  final step */
      u = (double)(Cg[0][g] - Cg[1][g]) + (double)(Cg[2][g] - Cg[3][g]);
      /*  we must do  u mod 2147483647 with u in [- 4294966863 ; 4294967066 ] : */
--    if (u < 0) u += 2147483647;
--    if (u < 0) u += 2147483647;
--    if (u >= 2147483647) u -= 2147483647;
--    if (u >= 2147483647) u -= 2147483647;
++    if (u < 0)
++    {
++        u += 2147483647;
++    }
++    if (u < 0)
++    {
++        u += 2147483647;
++    }
++    if (u >= 2147483647)
++    {
++        u -= 2147483647;
++    }
++    if (u >= 2147483647)
++    {
++        u -= 2147483647;
++    }
  
      return ((unsigned int) u );
  
@@@ -136,7 -144,7 +142,7 @@@ void UpdateBrowseVar(BOOL update
          }
          else
          {
--            pstAllVariableListTypes[i] = strdup("");
++            pstAllVariableListTypes[i] = os_strdup("");
          }
  
  
          piAllVariableBytes[i] = getGlobalSizefromId(j) * 8;
          // type
          // Calling "API Scilab": not yet implemented for global variable
 -        //getNamedVarType(pvApiCtx, pstAllVariableNames[i], &piAllVariableTypes[i]);
 +        //getNamedVarType(NULL, pstAllVariableNames[i], &piAllVariableTypes[i]);
          // Using old stack operations...
 -        int pos = C2F(vstk).isiz + 2 + j;
 +        //int pos = C2F(vstk).isiz + 2 + j;
  
 -        piAllVariableTypes[i] = C2F(gettype) (&pos);
 +        //piAllVariableTypes[i] = C2F(gettype) (&pos);
 +        getNamedVarType(NULL, pstAllVariableNames[i], &piAllVariableTypes[i]);
  
          // Sizes of the variable
 -        getNamedVarDimension(pvApiCtx, pstAllVariableNames[i], &nbRows, &nbCols);
 +        getNamedVarDimension(NULL, pstAllVariableNames[i], &nbRows, &nbCols);
          pstAllVariableSizes[i] = valueToDisplay(pstAllVariableNames[i], piAllVariableTypes[i], nbRows, nbCols);
+         piAllVariableNbRows[i] = nbRows;
+         piAllVariableNbCols[i] = nbCols;
  
          // global / local ??
 -        pstAllVariableVisibility[i] = strdup("global");
 +        pstAllVariableVisibility[i] = os_strdup("global");
  
  
          if (piAllVariableTypes[i] == sci_tlist || piAllVariableTypes[i] == sci_mlist)
@@@ -323,39 -346,40 +345,38 @@@ static char * getListName(char * variab
      return tmpChar;
  }
  
- static char * valueToDisplay(char * variableName, int variableType, int nbRows, int nbCols) {
+ static char * valueToDisplay(char * variableName, int variableType, int nbRows, int nbCols)
+ {
      SciErr err;
 -
 -
+     // 4 is the dimension max to which display the content
+     if (nbRows * nbCols <= 4 && variableType == sci_matrix)
+     {
+         // Small double value, display it
+         double* pdblReal = (double *)malloc(((nbRows) * (nbCols)) * sizeof(double));
+         double* pdblImg = (double *)malloc(((nbRows) * (nbCols)) * sizeof(double));
+         BOOL isComplex = FALSE;
  
 -        if (isNamedVarComplex(pvApiCtx, variableName))
++        if (isNamedVarComplex(NULL, variableName))
+         {
 -            err = readNamedComplexMatrixOfDouble(pvApiCtx, variableName, &nbRows, &nbCols, pdblReal, pdblImg);
++            err = readNamedComplexMatrixOfDouble(NULL, variableName, &nbRows, &nbCols, pdblReal, pdblImg);
+             isComplex = TRUE;
+         }
+         else
+         {
 -            err = readNamedMatrixOfDouble(pvApiCtx, variableName, &nbRows, &nbCols, pdblReal);
++            err = readNamedMatrixOfDouble(NULL, variableName, &nbRows, &nbCols, pdblReal);
+         }
  
-             // 4 is the dimension max to which display the content
-             if (nbRows * nbCols <= 4 && variableType == sci_matrix)
-             {
-                 // Small double value, display it
-                 double* pdblReal = (double *)malloc(((nbRows) * (nbCols)) * sizeof(double));
-                 double* pdblImg = (double *)malloc(((nbRows) * (nbCols)) * sizeof(double));
-                 BOOL isComplex = FALSE;
-                 if (isNamedVarComplex(NULL, variableName))
-                 {
-                     err = readNamedComplexMatrixOfDouble(NULL, variableName, &nbRows, &nbCols, pdblReal, pdblImg);
-                     isComplex = TRUE;
-                 }
-                 else
-                 {
-                     err = readNamedMatrixOfDouble(NULL, variableName, &nbRows, &nbCols, pdblReal);
-                 }
-                 return os_strdup(formatMatrix(nbRows, nbCols, isComplex, pdblReal, pdblImg).c_str());
-             }
-             else
-             {
-                 char *sizeStr = NULL;
-                 // 11 =strlen("2147483647")+1 (1 for security)
-                 sizeStr = (char *)MALLOC((11 + 11 + 1 + 1) * sizeof(char));
-                 sprintf(sizeStr, "%dx%d", nbRows, nbCols);
-                 return sizeStr;
-             }
 -        return strdup(formatMatrix(nbRows, nbCols, isComplex, pdblReal, pdblImg).c_str());
++        return os_strdup(formatMatrix(nbRows, nbCols, isComplex, pdblReal, pdblImg).c_str());
+     }
+     else
+     {
+         char *sizeStr = NULL;
+         // 11 =strlen("2147483647")+1 (1 for security)
+         sizeStr = (char *)MALLOC((11 + 11 + 1 + 1) * sizeof(char));
+         sprintf(sizeStr, "%dx%d", nbRows, nbCols);
+         return sizeStr;
+     }
  }
  
  std::string formatMatrix(int nbRows, int nbCols, BOOL isComplex, double *pdblReal, double *pdblImg)
Simple merge