LCOV - code coverage report
Current view: top level - monetdb5/mal - mal_builder.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 142 367 38.7 %
Date: 2021-10-13 02:24:04 Functions: 19 39 48.7 %

          Line data    Source code
       1             : /*
       2             :  * This Source Code Form is subject to the terms of the Mozilla Public
       3             :  * License, v. 2.0.  If a copy of the MPL was not distributed with this
       4             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       5             :  *
       6             :  * Copyright 1997 - July 2008 CWI, August 2008 - 2021 MonetDB B.V.
       7             :  */
       8             : 
       9             : /*
      10             :  * (authors) M. Kersten
      11             :  *
      12             :  * MAL builder
      13             :  * The MAL builder library containst the primitives to simplify construction
      14             :  * of programs by compilers. It has grown out of the MonetDB/SQL code generator.
      15             :  * The strings being passed as arguments are copied in the process.
      16             :  *
      17             :  */
      18             : #include "monetdb_config.h"
      19             : #include "mal_builder.h"
      20             : #include "mal_function.h"
      21             : #include "mal_namespace.h"
      22             : 
      23             : InstrPtr
      24     2618692 : newAssignmentArgs(MalBlkPtr mb, int args)
      25             : {
      26     2618692 :         InstrPtr q = newInstructionArgs(mb, NULL, NULL, args);
      27             :         int k;
      28             : 
      29     2618692 :         if (q == NULL)
      30             :                 return NULL;
      31     2618692 :         k = newTmpVariable(mb,TYPE_any);
      32     2618692 :         if (k < 0) {
      33             :                 // construct an exception message to be passed to upper layers using ->errors
      34           0 :                 str msg = createException(MAL, "newAssignment", "Can not allocate variable");
      35           0 :                 addMalException(mb, msg);
      36           0 :                 freeException(msg);
      37             :         } else
      38     2618692 :                 getArg(q,0) =  k;
      39     2618692 :         pushInstruction(mb, q);
      40     2618692 :         return q;
      41             : }
      42             : 
      43             : InstrPtr
      44     2484128 : newAssignment(MalBlkPtr mb)
      45             : {
      46     2484128 :         return newAssignmentArgs(mb, MAXARG);
      47             : }
      48             : 
      49             : InstrPtr
      50     7198481 : newStmt(MalBlkPtr mb, const char *module, const char *name)
      51             : {
      52     7198481 :         return newStmtArgs(mb, module, name, MAXARG);
      53             : }
      54             : 
      55             : InstrPtr
      56     9148427 : newStmtArgs(MalBlkPtr mb, const char *module, const char *name, int args)
      57             : {
      58             :         InstrPtr q;
      59     9148427 :         const char *mName = putName(module), *nName = putName(name);
      60             : 
      61     9148428 :         q = newInstructionArgs(mb, mName, nName, args);
      62     9148429 :         if (q == NULL)
      63             :                 return NULL;
      64             : 
      65     9148429 :         setDestVar(q, newTmpVariable(mb, TYPE_any));
      66     9148428 :         if (getDestVar(q) < 0 || mb->errors != MAL_SUCCEED) {
      67           0 :                 str msg = createException(MAL, "newStmtArgs", "Can not allocate variable");
      68           0 :                 addMalException(mb, msg);
      69           0 :                 freeException(msg);
      70             :         }
      71     9148428 :         pushInstruction(mb, q);
      72     9148429 :         return q;
      73             : }
      74             : 
      75             : InstrPtr
      76           0 : newReturnStmt(MalBlkPtr mb)
      77             : {
      78           0 :         InstrPtr q = newInstruction(mb, NULL, NULL);
      79             :         int k;
      80             : 
      81           0 :         if (q == NULL)
      82             :                 return NULL;
      83           0 :         k = newTmpVariable(mb,TYPE_any);
      84           0 :         if (k < 0 ){
      85           0 :                 str msg = createException(MAL, "newReturnStmt", "Can not allocate return variable");
      86           0 :                 addMalException(mb, msg);
      87           0 :                 freeException(msg);
      88             :         } else
      89           0 :                 getArg(q,0) = k;
      90           0 :         q->barrier= RETURNsymbol;
      91           0 :         pushInstruction(mb, q);
      92           0 :         return q;
      93             : }
      94             : 
      95             : InstrPtr
      96      134564 : newFcnCallArgs(MalBlkPtr mb, const char *mod, const char *fcn, int args)
      97             : {
      98      134564 :         InstrPtr q = newAssignmentArgs(mb, args);
      99             :         const char *fcnName, *modName;
     100             : 
     101      134564 :         modName = putName(mod);
     102      134564 :         fcnName = putName(fcn);
     103      134564 :         setModuleId(q, modName);
     104      134564 :         setFunctionId(q, fcnName);
     105      134564 :         return q;
     106             : }
     107             : 
     108             : InstrPtr
     109      133359 : newFcnCall(MalBlkPtr mb, const char *mod, const char *fcn)
     110             : {
     111      133359 :         return newFcnCallArgs(mb, mod, fcn, MAXARG);
     112             : }
     113             : 
     114             : InstrPtr
     115           0 : newComment(MalBlkPtr mb, const char *val)
     116             : {
     117           0 :         InstrPtr q = newInstruction(mb, NULL, NULL);
     118             :         ValRecord cst;
     119             :         int k;
     120             : 
     121           0 :         if (q == NULL)
     122             :                 return NULL;
     123           0 :         q->token = REMsymbol;
     124           0 :         q->barrier = 0;
     125           0 :         if (VALinit(&cst, TYPE_str, val) == NULL) {
     126           0 :                 str msg = createException(MAL, "newComment", "Can not allocate comment");
     127           0 :                 addMalException(mb, msg);
     128           0 :                 freeException(msg);
     129             :         } else {
     130           0 :                 k = defConstant(mb, TYPE_str, &cst);
     131           0 :                 if( k >= 0){
     132           0 :                         getArg(q,0) = k;
     133           0 :                         clrVarConstant(mb,getArg(q,0));
     134           0 :                         setVarDisabled(mb,getArg(q,0));
     135             :                 }
     136             :         }
     137           0 :         pushInstruction(mb, q);
     138           0 :         return q;
     139             : }
     140             : 
     141             : InstrPtr
     142         250 : newCatchStmt(MalBlkPtr mb, const char *nme)
     143             : {
     144         250 :         InstrPtr q = newAssignment(mb);
     145         250 :         int i= findVariable(mb,nme);
     146             :         int k;
     147             : 
     148         250 :         if (q == NULL)
     149             :                 return NULL;
     150         250 :         q->barrier = CATCHsymbol;
     151         250 :         if ( i< 0) {
     152         250 :                 k = newVariable(mb, nme, strlen(nme),TYPE_str);
     153         250 :                 if (k<0){
     154           0 :                         str msg = createException(MAL, "newCatchStmt", "Can not allocate variable");
     155           0 :                         addMalException(mb, msg);
     156           0 :                         freeException(msg);
     157             :                 }else{
     158         250 :                         getArg(q,0) = k;
     159             :                 }
     160           0 :         } else getArg(q,0) = i;
     161             :         return q;
     162             : }
     163             : 
     164             : InstrPtr
     165           0 : newRaiseStmt(MalBlkPtr mb, const char *nme)
     166             : {
     167           0 :         InstrPtr q = newAssignment(mb);
     168           0 :         int i= findVariable(mb,nme);
     169             :         int k;
     170             : 
     171           0 :         if (q == NULL)
     172             :                 return NULL;
     173           0 :         q->barrier = RAISEsymbol;
     174           0 :         if ( i< 0) {
     175           0 :                 k = newVariable(mb, nme, strlen(nme),TYPE_str);
     176           0 :                 if (k< 0 || mb->errors != MAL_SUCCEED) {
     177           0 :                         str msg = createException(MAL, "newRaiseStmt", "Can not allocate variable");
     178           0 :                         addMalException(mb, msg);
     179           0 :                         freeException(msg);
     180             :                 } else
     181           0 :                         getArg(q,0) = k;
     182             :         } else
     183           0 :                 getArg(q,0) = i;
     184             :         return q;
     185             : }
     186             : 
     187             : InstrPtr
     188         250 : newExitStmt(MalBlkPtr mb, const char *nme)
     189             : {
     190         250 :         InstrPtr q = newAssignment(mb);
     191         250 :         int i= findVariable(mb,nme);
     192             :         int k;
     193             : 
     194         250 :         if (q == NULL)
     195             :                 return NULL;
     196         250 :         q->barrier = EXITsymbol;
     197         250 :         if ( i< 0) {
     198           0 :                 k= newVariable(mb, nme,strlen(nme),TYPE_str);
     199           0 :                 if (k < 0 ){
     200           0 :                         str msg = createException(MAL, "newExitStmt", "Can not allocate variable");
     201           0 :                         addMalException(mb, msg);
     202           0 :                         freeException(msg);
     203             :                 }else
     204           0 :                         getArg(q,0) = k;
     205             :         } else
     206         250 :                 getArg(q,0) = i;
     207             :         return q;
     208             : }
     209             : 
     210             : InstrPtr
     211      397337 : pushEndInstruction(MalBlkPtr mb)
     212             : {
     213      397337 :     InstrPtr q = newInstruction(mb,NULL, NULL);
     214             : 
     215      397338 :         if (q == NULL)
     216             :                 return NULL;
     217      397338 :     q->token = ENDsymbol;
     218      397338 :     q->barrier = 0;
     219      397338 :     q->argc = 0;
     220      397338 :     q->retc = 0;
     221      397338 :     q->argv[0] = 0;
     222      397338 :     pushInstruction(mb, q);
     223      397338 :         return q;
     224             : }
     225             : 
     226             : int
     227     1011385 : getIntConstant(MalBlkPtr mb, int val)
     228             : {
     229             :         int _t;
     230             :         ValRecord cst;
     231             : 
     232     1011385 :         cst.vtype= TYPE_int;
     233     1011385 :         cst.val.ival= val;
     234     1011385 :         cst.len = 0;
     235     1011385 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     236     1011385 :         if( _t < 0)
     237      428560 :                 _t = defConstant(mb, TYPE_int, &cst);
     238     1011384 :         assert(_t >= 0);
     239     1011384 :         return _t;
     240             : }
     241             : 
     242             : InstrPtr
     243    13761011 : pushInt(MalBlkPtr mb, InstrPtr q, int val)
     244             : {
     245             :         int _t;
     246             :         ValRecord cst;
     247             : 
     248    13761011 :         if (q == NULL)
     249             :                 return NULL;
     250    13761011 :         cst.vtype= TYPE_int;
     251    13761011 :         cst.val.ival= val;
     252    13761011 :         cst.len = 0;
     253    13761011 :         _t = defConstant(mb, TYPE_int, &cst);
     254    13761002 :         if( _t >= 0)
     255    13761002 :                 return pushArgument(mb, q, _t);
     256             :         return q;
     257             : }
     258             : 
     259             : int
     260           0 : getBteConstant(MalBlkPtr mb, bte val)
     261             : {
     262             :         int _t;
     263             :         ValRecord cst;
     264             : 
     265           0 :         cst.vtype= TYPE_bte;
     266           0 :         cst.val.btval= val;
     267           0 :         cst.len = 0;
     268           0 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     269           0 :         if( _t < 0)
     270           0 :                 _t = defConstant(mb, TYPE_bte, &cst);
     271           0 :         assert(_t >= 0);
     272           0 :         return _t;
     273             : }
     274             : 
     275             : InstrPtr
     276           0 : pushBte(MalBlkPtr mb, InstrPtr q, bte val)
     277             : {
     278             :         int _t;
     279             :         ValRecord cst;
     280             : 
     281           0 :         if (q == NULL)
     282             :                 return NULL;
     283           0 :         cst.vtype= TYPE_bte;
     284           0 :         cst.val.btval= val;
     285           0 :         cst.len = 0;
     286           0 :         _t = defConstant(mb, TYPE_bte,&cst);
     287           0 :         if( _t >= 0)
     288           0 :                 return pushArgument(mb, q, _t);
     289             :         return q;
     290             : }
     291             : 
     292             : int
     293           0 : getOidConstant(MalBlkPtr mb, oid val)
     294             : {
     295             :         int _t;
     296             :         ValRecord cst;
     297             : 
     298           0 :         cst.vtype= TYPE_oid;
     299           0 :         cst.val.oval= val;
     300           0 :         cst.len = 0;
     301           0 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     302           0 :         if( _t < 0)
     303           0 :                 _t = defConstant(mb, TYPE_oid, &cst);
     304           0 :         assert(_t >= 0);
     305           0 :         return _t;
     306             : }
     307             : 
     308             : InstrPtr
     309         348 : pushOid(MalBlkPtr mb, InstrPtr q, oid val)
     310             : {
     311             :         int _t;
     312             :         ValRecord cst;
     313             : 
     314         348 :         if (q == NULL)
     315             :                 return NULL;
     316         348 :         cst.vtype= TYPE_oid;
     317         348 :         cst.val.oval= val;
     318         348 :         cst.len = 0;
     319         348 :         _t = defConstant(mb,TYPE_oid,&cst);
     320         348 :         if( _t >= 0)
     321         348 :                 return pushArgument(mb, q, _t);
     322             :         return q;
     323             : }
     324             : 
     325             : InstrPtr
     326           0 : pushVoid(MalBlkPtr mb, InstrPtr q)
     327             : {
     328             :         int _t;
     329             :         ValRecord cst;
     330             : 
     331           0 :         if (q == NULL)
     332             :                 return NULL;
     333           0 :         cst.vtype= TYPE_void;
     334           0 :         cst.val.oval= oid_nil;
     335           0 :         cst.len = 0;
     336           0 :         _t = defConstant(mb,TYPE_void,&cst);
     337           0 :         if( _t >= 0)
     338           0 :                 return pushArgument(mb, q, _t);
     339             :         return q;
     340             : }
     341             : 
     342             : int
     343           0 : getLngConstant(MalBlkPtr mb, lng val)
     344             : {
     345             :         int _t;
     346             :         ValRecord cst;
     347             : 
     348           0 :         cst.vtype= TYPE_lng;
     349           0 :         cst.val.lval= val;
     350           0 :         cst.len = 0;
     351           0 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     352           0 :         if( _t < 0)
     353           0 :                 _t = defConstant(mb, TYPE_lng, &cst);
     354           0 :         assert(_t >= 0);
     355           0 :         return _t;
     356             : }
     357             : 
     358             : InstrPtr
     359    10880402 : pushLng(MalBlkPtr mb, InstrPtr q, lng val)
     360             : {
     361             :         int _t;
     362             :         ValRecord cst;
     363             : 
     364    10880402 :         if (q == NULL)
     365             :                 return NULL;
     366    10880402 :         cst.vtype= TYPE_lng;
     367    10880402 :         cst.val.lval= val;
     368    10880402 :         cst.len = 0;
     369    10880402 :         _t = defConstant(mb,TYPE_lng,&cst);
     370    10880397 :         if( _t >= 0)
     371    10880397 :                 return pushArgument(mb, q, _t);
     372             :         return q;
     373             : }
     374             : 
     375             : int
     376           0 : getShtConstant(MalBlkPtr mb, sht val)
     377             : {
     378             :         int _t;
     379             :         ValRecord cst;
     380             : 
     381           0 :         cst.vtype= TYPE_sht;
     382           0 :         cst.val.shval= val;
     383           0 :         cst.len = 0;
     384           0 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     385           0 :         if( _t < 0)
     386           0 :                 _t = defConstant(mb, TYPE_sht, &cst);
     387           0 :         assert(_t >=0);
     388           0 :         return _t;
     389             : }
     390             : 
     391             : InstrPtr
     392           0 : pushSht(MalBlkPtr mb, InstrPtr q, sht val)
     393             : {
     394             :         int _t;
     395             :         ValRecord cst;
     396             : 
     397           0 :         if (q == NULL)
     398             :                 return NULL;
     399           0 :         cst.vtype= TYPE_sht;
     400           0 :         cst.val.shval= val;
     401           0 :         cst.len = 0;
     402           0 :         _t = defConstant(mb,TYPE_sht,&cst);
     403           0 :         if( _t >= 0)
     404           0 :                 return pushArgument(mb, q, _t);
     405             :         return q;
     406             : }
     407             : 
     408             : #ifdef HAVE_HGE
     409             : int
     410           0 : getHgeConstant(MalBlkPtr mb, hge val)
     411             : {
     412             :         int _t;
     413             :         ValRecord cst;
     414             : 
     415           0 :         cst.vtype= TYPE_oid;
     416           0 :         cst.val.hval= val;
     417           0 :         cst.len = 0;
     418           0 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     419           0 :         if( _t < 0)
     420           0 :                 _t = defConstant(mb, TYPE_hge, &cst);
     421           0 :         assert(_t >= 0);
     422           0 :         return _t;
     423             : }
     424             : 
     425             : InstrPtr
     426           0 : pushHge(MalBlkPtr mb, InstrPtr q, hge val)
     427             : {
     428             :         int _t;
     429             :         ValRecord cst;
     430             : 
     431           0 :         if (q == NULL)
     432             :                 return NULL;
     433           0 :         cst.vtype= TYPE_hge;
     434           0 :         cst.val.hval= val;
     435           0 :         cst.len = 0;
     436           0 :         _t = defConstant(mb,TYPE_hge,&cst);
     437           0 :         if (_t >= 0)
     438           0 :                 return pushArgument(mb, q, _t);
     439             :         return q;
     440             : }
     441             : #endif
     442             : 
     443             : int
     444           0 : getDblConstant(MalBlkPtr mb, dbl val)
     445             : {
     446             :         int _t;
     447             :         ValRecord cst;
     448             : 
     449           0 :         cst.vtype= TYPE_dbl;
     450           0 :         cst.val.dval= val;
     451           0 :         cst.len = 0;
     452           0 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     453           0 :         if( _t < 0)
     454           0 :                 _t = defConstant(mb, TYPE_dbl, &cst);
     455           0 :         assert(_t >= 0);
     456           0 :         return _t;
     457             : }
     458             : 
     459             : InstrPtr
     460           0 : pushDbl(MalBlkPtr mb, InstrPtr q, dbl val)
     461             : {
     462             :         int _t;
     463             :         ValRecord cst;
     464             : 
     465           0 :         if (q == NULL)
     466             :                 return NULL;
     467           0 :         cst.vtype= TYPE_dbl;
     468           0 :         cst.val.dval= val;
     469           0 :         cst.len = 0;
     470           0 :         _t = defConstant(mb,TYPE_dbl,&cst);
     471           0 :         if( _t >= 0)
     472           0 :                 return pushArgument(mb, q, _t);
     473             :         return q;
     474             : }
     475             : 
     476             : int
     477           0 : getFltConstant(MalBlkPtr mb, flt val)
     478             : {
     479             :         int _t;
     480             :         ValRecord cst;
     481             : 
     482           0 :         cst.vtype= TYPE_flt;
     483           0 :         cst.val.fval= val;
     484           0 :         cst.len = 0;
     485           0 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     486           0 :         if( _t < 0)
     487           0 :                 _t = defConstant(mb, TYPE_flt, &cst);
     488           0 :         assert(_t >= 0);
     489           0 :         return _t;
     490             : }
     491             : 
     492             : InstrPtr
     493           0 : pushFlt(MalBlkPtr mb, InstrPtr q, flt val)
     494             : {
     495             :         int _t;
     496             :         ValRecord cst;
     497             : 
     498           0 :         if (q == NULL)
     499             :                 return NULL;
     500           0 :         cst.vtype= TYPE_flt;
     501           0 :         cst.val.fval= val;
     502           0 :         cst.len = 0;
     503           0 :         _t = defConstant(mb,TYPE_flt,&cst);
     504           0 :         if( _t >= 0)
     505           0 :                 return pushArgument(mb, q, _t);
     506             :         return q;
     507             : }
     508             : 
     509             : int
     510     3789767 : getStrConstant(MalBlkPtr mb, str val)
     511             : {
     512             :         int _t;
     513             :         ValRecord cst;
     514             : 
     515     3789767 :         VALset(&cst, TYPE_str, val);
     516     3789767 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     517     3789768 :         if( _t < 0) {
     518     1036719 :                 if ((cst.val.sval = GDKmalloc(cst.len)) == NULL)
     519             :                         return -1;
     520     1036719 :                 memcpy(cst.val.sval, val, cst.len); /* includes terminating \0 */
     521     1036719 :                 _t = defConstant(mb, TYPE_str, &cst);
     522             :         }
     523     3789768 :         assert(_t >= 0);
     524             :         return _t;
     525             : }
     526             : 
     527             : InstrPtr
     528     2749967 : pushStr(MalBlkPtr mb, InstrPtr q, const char *Val)
     529             : {
     530             :         int _t;
     531             :         ValRecord cst;
     532             : 
     533     2749967 :         if (q == NULL)
     534             :                 return NULL;
     535     2749967 :         if (VALinit(&cst, TYPE_str, Val) == NULL) {
     536           0 :                 str msg = createException(MAL, "pushStr", "Can not allocate string variable");
     537           0 :                 addMalException(mb, msg);
     538           0 :                 freeException(msg);
     539             :         } else{
     540     2749967 :                 _t = defConstant(mb,TYPE_str,&cst);
     541     2749967 :                 if( _t >= 0)
     542     2749967 :                         return pushArgument(mb, q, _t);
     543             :         }
     544             :         return q;
     545             : }
     546             : 
     547             : int
     548           0 : getBitConstant(MalBlkPtr mb, bit val)
     549             : {
     550             :         int _t;
     551             :         ValRecord cst;
     552             : 
     553           0 :         cst.vtype= TYPE_bit;
     554           0 :         cst.val.btval= val;
     555           0 :         cst.len = 0;
     556           0 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     557           0 :         if( _t < 0)
     558           0 :                 _t = defConstant(mb, TYPE_bit, &cst);
     559           0 :         assert(_t >= 0);
     560           0 :         return _t;
     561             : }
     562             : 
     563             : InstrPtr
     564     1097577 : pushBit(MalBlkPtr mb, InstrPtr q, bit val)
     565             : {
     566             :         int _t;
     567             :         ValRecord cst;
     568             : 
     569     1097577 :         if (q == NULL)
     570             :                 return NULL;
     571     1097577 :         cst.vtype= TYPE_bit;
     572     1097577 :         cst.val.btval= val;
     573     1097577 :         cst.len = 0;
     574     1097577 :         _t = defConstant(mb,TYPE_bit,&cst);
     575     1097577 :         if( _t >= 0)
     576     1097577 :                 return pushArgument(mb, q, _t);
     577             :         return q;
     578             : }
     579             : 
     580             : InstrPtr
     581      891385 : pushNil(MalBlkPtr mb, InstrPtr q, int tpe)
     582             : {
     583             :         int _t;
     584             :         ValRecord cst;
     585             : 
     586      891385 :         if (q == NULL)
     587             :                 return NULL;
     588      891385 :         cst.len = 0;
     589      891385 :         if( !isaBatType(tpe) && tpe != TYPE_bat ) {
     590      316868 :                 assert(tpe < MAXATOMS);      /* in particular, tpe!=TYPE_any */
     591      316868 :                 if (!tpe) {
     592         695 :                         cst.vtype=TYPE_void;
     593         695 :                         cst.val.oval= oid_nil;
     594             :                 } else {
     595      316173 :                         if (VALinit(&cst, tpe, ATOMnilptr(tpe)) == NULL) {
     596           0 :                                 str msg =  createException(MAL, "pushNil", "Can not allocate nil variable");
     597           0 :                                 addMalException(mb, msg);
     598           0 :                                 freeException(msg);
     599             :                         }
     600             :                 }
     601      316868 :                 _t = defConstant(mb,tpe,&cst);
     602             :         } else {
     603      574517 :                 cst.vtype = TYPE_bat;
     604      574517 :                 cst.val.bval = bat_nil;
     605      574517 :                 _t = defConstant(mb,TYPE_bat,&cst);
     606      574517 :                 getVarType(mb,_t) = tpe;
     607             :         }
     608      891385 :         if( _t >= 0){
     609      891385 :                 q= pushArgument(mb, q, _t);
     610             :         }
     611             :         return q;
     612             : }
     613             : 
     614             : InstrPtr
     615           0 : pushNilType(MalBlkPtr mb, InstrPtr q, char *tpe)
     616             : {
     617             :         int _t,idx;
     618             :         ValRecord cst;
     619             :         str msg;
     620             : 
     621           0 :         if (q == NULL)
     622             :                 return NULL;
     623           0 :         idx= getAtomIndex(tpe, strlen(tpe), TYPE_any);
     624           0 :         if( idx < 0 || idx >= GDKatomcnt || idx >= MAXATOMS){
     625           0 :                 str msg = createException(MAL, "pushNilType", "Can not allocate type variable");
     626           0 :                 addMalException(mb, msg);
     627           0 :                 freeException(msg);
     628             :         } else {
     629           0 :                 cst.vtype=TYPE_void;
     630           0 :                 cst.val.oval= oid_nil;
     631           0 :                 cst.len = 0;
     632           0 :                 msg = convertConstant(idx, &cst);
     633           0 :                 if (msg != MAL_SUCCEED) {
     634           0 :                         addMalException(mb, msg);
     635           0 :                         freeException(msg);
     636             :                 } else {
     637           0 :                         _t = defConstant(mb,idx,&cst);
     638           0 :                         if( _t >= 0){
     639           0 :                                 return pushArgument(mb, q, _t);
     640             :                         }
     641             :                 }
     642             :         }
     643             :         return q;
     644             : }
     645             : 
     646             : InstrPtr
     647      335743 : pushType(MalBlkPtr mb, InstrPtr q, int tpe)
     648             : {
     649             :         int _t;
     650             :         ValRecord cst;
     651             :         str msg;
     652             : 
     653      335743 :         if (q == NULL)
     654             :                 return NULL;
     655      335743 :         cst.vtype=TYPE_void;
     656      335743 :         cst.val.oval= oid_nil;
     657      335743 :         cst.len = 0;
     658      335743 :         msg = convertConstant(tpe, &cst);
     659      335742 :         if (msg != MAL_SUCCEED){
     660           0 :                 addMalException(mb, msg);
     661           0 :                 freeException(msg);
     662             :         } else {
     663      335742 :                 _t = defConstant(mb,tpe,&cst);
     664      335743 :                 if( _t >= 0){
     665      335743 :                         return pushArgument(mb, q, _t);
     666             :                 }
     667             :         }
     668             :         return q;
     669             : }
     670             : 
     671             : InstrPtr
     672           0 : pushZero(MalBlkPtr mb, InstrPtr q, int tpe)
     673             : {
     674             :         int _t;
     675             :         ValRecord cst;
     676             :         str msg;
     677             : 
     678           0 :         if (q == NULL)
     679             :                 return NULL;
     680           0 :         cst.vtype=TYPE_int;
     681           0 :         cst.val.ival= 0;
     682           0 :         cst.len = 0;
     683           0 :         msg = convertConstant(tpe, &cst);
     684           0 :         if (msg != MAL_SUCCEED) {
     685           0 :                 addMalException(mb, msg);
     686           0 :                 freeException(msg);
     687             :         } else {
     688           0 :                 _t = defConstant(mb,tpe,&cst);
     689           0 :                 if( _t >= 0)
     690           0 :                         return pushArgument(mb, q, _t);
     691             :         }
     692             :         return q;
     693             : }
     694             : 
     695             : InstrPtr
     696           0 : pushEmptyBAT(MalBlkPtr mb, InstrPtr q, int tpe)
     697             : {
     698           0 :         if (q == NULL)
     699             :                 return NULL;
     700           0 :         setModuleId(q, getName("bat"));
     701           0 :         setFunctionId(q, getName("new"));
     702             : 
     703           0 :         q = pushArgument(mb, q, newTypeVariable(mb,TYPE_void));
     704           0 :         q = pushArgument(mb, q, newTypeVariable(mb,getBatType(tpe)));
     705           0 :         q = pushZero(mb,q,TYPE_lng);
     706           0 :         return q;
     707             : }
     708             : 
     709             : InstrPtr
     710           1 : pushValue(MalBlkPtr mb, InstrPtr q, ValPtr vr)
     711             : {
     712             :         int _t;
     713             :         ValRecord cst;
     714             : 
     715           1 :         if (q == NULL)
     716             :                 return NULL;
     717           1 :         if (VALcopy(&cst, vr) == NULL) {
     718           0 :                 str msg = createException(MAL, "pushValue", "Can not allocate variable");
     719           0 :                 addMalException(mb, msg);
     720           0 :                 freeException(msg);
     721             :         } else {
     722           1 :                 _t = defConstant(mb,cst.vtype,&cst);
     723           1 :                 if( _t >=0 )
     724           1 :                         return pushArgument(mb, q, _t);
     725             :         }
     726             :         return q;
     727             : }

Generated by: LCOV version 1.14