scilab/modules/graphics/sci_gateway/c/sci_champ.c

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2006 - INRIA - Fabrice Leray
   4  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
   5  * Copyright (C) 2011 - DIGITEO - Bruno JOFRET
   6  *
   7  * This file must be used under the terms of the CeCILL.
   8  * This source file is licensed as described in the file COPYING, which
   9  * you should have received as part of this distribution.  The terms
  10  * are also available at
  11  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  12  *
  13  */
  14
  15 /*------------------------------------------------------------------------*/
  16 /* file: sci_champ.c                                                      */
  17 /* desc : interface for champ (and champ1) routine                        */
  18 /*------------------------------------------------------------------------*/
  19
  20 #include "gw_graphics.h"
  21 #include "api_scilab.h"
  22 #include "GetCommandArg.h"
  23 #include "BuildObjects.h"
  24 #include "DefaultCommandArg.h"
  25 #include "Champ.h"
  26 #include "localization.h"
  27 #include "Scierror.h"
  28 /*--------------------------------------------------------------------------*/
  29 int sci_champ (char *fname, unsigned long fname_len)
  30 {
  31     return sci_champ_G(fname, C2F(champ), fname_len);
  32 }
  33 /*--------------------------------------------------------------------------*/
  34 int sci_champ1 (char *fname, unsigned long fname_len)
  35 {
  36     return sci_champ_G(fname, C2F(champ1), fname_len);
  37 }
  38 /*--------------------------------------------------------------------------*/
  39 int sci_champ_G(char *fname,
  40                 int (*func) (double *, double *, double *, double *, int *, int *, char *, double *, double *, int),
  41                 unsigned long fname_len)
  42 {
  43     SciErr sciErr;
  44     double arfact_def = 1.0;
  45     double* arfact = &arfact_def;
  46     int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0, m4 = 0, n4 = 0;
  47     static rhs_opts opts[] =
  48     {
  49         { -1, "arfact", -1, 0, 0, NULL},
  50         { -1, "rect", -1, 0, 0, NULL},
  51         { -1, "strf", -1, 0, 0, NULL},
  52         { -1, NULL, -1, 0, 0, NULL}
  53     };
  54
  55     char   * strf = NULL;
  56     double* rect = NULL;
  57
  58     int* piAddr1 = NULL;
  59     int* piAddr2 = NULL;
  60     int* piAddr3 = NULL;
  61     int* piAddr4 = NULL;
  62
  63     double* l1 = NULL;
  64     double* l2 = NULL;
  65     double* l3 = NULL;
  66     double* l4 = NULL;
  67
  68     CheckInputArgument(pvApiCtx, -1, 7);
  69     CheckOutputArgument(pvApiCtx, 0, 1);
  70
  71     if (nbInputArgument(pvApiCtx) <= 0)
  72     {
  73         sci_demo(fname, fname_len);
  74         return 0;
  75     }
  76     else if (nbInputArgument(pvApiCtx) < 4)
  77     {
  78         Scierror(999, _("%s: Wrong number of input arguments: At least %d expected.\n"), fname, 4);
  79         return 0;
  80     }
  81
  82     if (getOptionals(pvApiCtx, fname, opts) == 0)
  83     {
  84         return 0;
  85     }
  86
  87     if (FirstOpt() < 5)
  88     {
  89         Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 5);
  90         return -1;
  91     }
  92
  93     //get variable address
  94     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
  95     if (sciErr.iErr)
  96     {
  97         printError(&sciErr, 0);
  98         return 1;
  99     }
 100
 101     // Retrieve a matrix of double at position 1.
 102     sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, &l1);
 103     if (sciErr.iErr)
 104     {
 105         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
 106         printError(&sciErr, 0);
 107         return 1;
 108     }
 109
 110     //get variable address
 111     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
 112     if (sciErr.iErr)
 113     {
 114         printError(&sciErr, 0);
 115         return 1;
 116     }
 117
 118     // Retrieve a matrix of double at position 2.
 119     sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2);
 120     if (sciErr.iErr)
 121     {
 122         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
 123         printError(&sciErr, 0);
 124         return 1;
 125     }
 126
 127     //get variable address
 128     sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
 129     if (sciErr.iErr)
 130     {
 131         printError(&sciErr, 0);
 132         return 1;
 133     }
 134
 135     // Retrieve a matrix of double at position 3.
 136     sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
 137     if (sciErr.iErr)
 138     {
 139         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
 140         printError(&sciErr, 0);
 141         return 1;
 142     }
 143
 144     //get variable address
 145     sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
 146     if (sciErr.iErr)
 147     {
 148         printError(&sciErr, 0);
 149         return 1;
 150     }
 151
 152     // Retrieve a matrix of double at position 4.
 153     sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &m4, &n4, &l4);
 154     if (sciErr.iErr)
 155     {
 156         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 4);
 157         printError(&sciErr, 0);
 158         return 1;
 159     }
 160
 161     //CheckSameDims
 162     if (m3 != m4 || n3 != n4)
 163     {
 164         Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 3, m3, n3);
 165         return 1;
 166     }
 167
 168     //CheckDimProp
 169     if (m2 * n2 != n3)
 170     {
 171         Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
 172         return 1;
 173     }
 174
 175     //CheckDimProp
 176     if (m1 * n1 != m3)
 177     {
 178         Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
 179         return 1;
 180     }
 181
 182     if (m3 * n3 == 0)
 183     {
 184         AssignOutputVariable(pvApiCtx, 1) = 0;
 185         ReturnArguments(pvApiCtx);
 186         return 0;
 187     }
 188
 189     GetOptionalDoubleArg(pvApiCtx, fname, 5, "arfact", &arfact, 1, opts);
 190     GetRect(pvApiCtx, fname, 6, opts, &rect);
 191     GetStrf(pvApiCtx, fname, 7, opts, &strf);
 192
 193     getOrCreateDefaultSubwin();
 194
 195     if (isDefStrf(strf))
 196     {
 197         char strfl[4];
 198         strcpy(strfl, DEFSTRFN);
 199         strf = strfl;
 200         if (!isDefRect(rect))
 201         {
 202             strf[1] = '5';
 203         }
 204     }
 205
 206     (*func)((l1), (l2), (l3), (l4), &m3, &n3, strf, rect, arfact, 4L);
 207     AssignOutputVariable(pvApiCtx, 1) = 0;
 208     ReturnArguments(pvApiCtx);
 209     return 0;
 210 }
 211 /*--------------------------------------------------------------------------*/