LCOV - code coverage report
Current view: top level - monetdb5/mal - mal_builder.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 149 379 39.3 %
Date: 2021-09-14 22:17:06 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     2590330 : newAssignmentArgs(MalBlkPtr mb, int args)
      25             : {
      26     2590330 :         InstrPtr q = newInstructionArgs(mb, NULL, NULL, args);
      27             :         int k;
      28             : 
      29     2590331 :         if (q == NULL)
      30             :                 return NULL;
      31     2590331 :         k = newTmpVariable(mb,TYPE_any);
      32     2590331 :         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     2590331 :                 getArg(q,0) =  k;
      39     2590331 :         pushInstruction(mb, q);
      40     2590331 :         return q;
      41             : }
      42             : 
      43             : InstrPtr
      44     2461296 : newAssignment(MalBlkPtr mb)
      45             : {
      46     2461296 :         return newAssignmentArgs(mb, MAXARG);
      47             : }
      48             : 
      49             : InstrPtr
      50     7144826 : newStmt(MalBlkPtr mb, const char *module, const char *name)
      51             : {
      52     7144826 :         return newStmtArgs(mb, module, name, MAXARG);
      53             : }
      54             : 
      55             : InstrPtr
      56     9075526 : newStmtArgs(MalBlkPtr mb, const char *module, const char *name, int args)
      57             : {
      58             :         InstrPtr q;
      59     9075526 :         const char *mName = putName(module), *nName = putName(name);
      60             : 
      61     9075528 :         q = newInstructionArgs(mb, mName, nName, args);
      62     9075526 :         if (q == NULL)
      63             :                 return NULL;
      64             : 
      65     9075526 :         setDestVar(q, newTmpVariable(mb, TYPE_any));
      66     9075527 :         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     9075527 :         pushInstruction(mb, q);
      72     9075527 :         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      129034 : newFcnCallArgs(MalBlkPtr mb, const char *mod, const char *fcn, int args)
      97             : {
      98      129034 :         InstrPtr q = newAssignmentArgs(mb, args);
      99             :         const char *fcnName, *modName;
     100             : 
     101      129034 :         modName = putName(mod);
     102      129034 :         fcnName = putName(fcn);
     103      129034 :         setModuleId(q, modName);
     104      129034 :         setFunctionId(q, fcnName);
     105      129034 :         return q;
     106             : }
     107             : 
     108             : InstrPtr
     109      127827 : newFcnCall(MalBlkPtr mb, const char *mod, const char *fcn)
     110             : {
     111      127827 :         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 :         cst.vtype= TYPE_str;
     126           0 :         if ((cst.val.sval= GDKstrdup(val)) == NULL) {
     127           0 :                 str msg = createException(MAL, "newComment", "Can not allocate comment");
     128           0 :                 addMalException(mb, msg);
     129           0 :                 freeException(msg);
     130             :         } else {
     131           0 :                 cst.len = strlen(cst.val.sval);
     132           0 :                 k = defConstant(mb, TYPE_str, &cst);
     133           0 :                 if( k >= 0){
     134           0 :                         getArg(q,0) = k;
     135           0 :                         clrVarConstant(mb,getArg(q,0));
     136           0 :                         setVarDisabled(mb,getArg(q,0));
     137             :                 }
     138             :         }
     139           0 :         pushInstruction(mb, q);
     140           0 :         return q;
     141             : }
     142             : 
     143             : InstrPtr
     144         134 : newCatchStmt(MalBlkPtr mb, const char *nme)
     145             : {
     146         134 :         InstrPtr q = newAssignment(mb);
     147         134 :         int i= findVariable(mb,nme);
     148             :         int k;
     149             : 
     150         134 :         if (q == NULL)
     151             :                 return NULL;
     152         134 :         q->barrier = CATCHsymbol;
     153         134 :         if ( i< 0) {
     154         134 :                 k = newVariable(mb, nme, strlen(nme),TYPE_str);
     155         134 :                 if (k<0){
     156           0 :                         str msg = createException(MAL, "newCatchStmt", "Can not allocate variable");
     157           0 :                         addMalException(mb, msg);
     158           0 :                         freeException(msg);
     159             :                 }else{
     160         134 :                         getArg(q,0) = k;
     161             :                 }
     162           0 :         } else getArg(q,0) = i;
     163             :         return q;
     164             : }
     165             : 
     166             : InstrPtr
     167           0 : newRaiseStmt(MalBlkPtr mb, const char *nme)
     168             : {
     169           0 :         InstrPtr q = newAssignment(mb);
     170           0 :         int i= findVariable(mb,nme);
     171             :         int k;
     172             : 
     173           0 :         if (q == NULL)
     174             :                 return NULL;
     175           0 :         q->barrier = RAISEsymbol;
     176           0 :         if ( i< 0) {
     177           0 :                 k = newVariable(mb, nme, strlen(nme),TYPE_str);
     178           0 :                 if (k< 0 || mb->errors != MAL_SUCCEED) {
     179           0 :                         str msg = createException(MAL, "newRaiseStmt", "Can not allocate variable");
     180           0 :                         addMalException(mb, msg);
     181           0 :                         freeException(msg);
     182             :                 } else
     183           0 :                         getArg(q,0) = k;
     184             :         } else
     185           0 :                 getArg(q,0) = i;
     186             :         return q;
     187             : }
     188             : 
     189             : InstrPtr
     190         134 : newExitStmt(MalBlkPtr mb, const char *nme)
     191             : {
     192         134 :         InstrPtr q = newAssignment(mb);
     193         134 :         int i= findVariable(mb,nme);
     194             :         int k;
     195             : 
     196         134 :         if (q == NULL)
     197             :                 return NULL;
     198         134 :         q->barrier = EXITsymbol;
     199         134 :         if ( i< 0) {
     200           0 :                 k= newVariable(mb, nme,strlen(nme),TYPE_str);
     201           0 :                 if (k < 0 ){
     202           0 :                         str msg = createException(MAL, "newExitStmt", "Can not allocate variable");
     203           0 :                         addMalException(mb, msg);
     204           0 :                         freeException(msg);
     205             :                 }else
     206           0 :                         getArg(q,0) = k;
     207             :         } else
     208         134 :                 getArg(q,0) = i;
     209             :         return q;
     210             : }
     211             : 
     212             : InstrPtr
     213      390074 : pushEndInstruction(MalBlkPtr mb)
     214             : {
     215      390074 :     InstrPtr q = newInstruction(mb,NULL, NULL);
     216             : 
     217      390075 :         if (q == NULL)
     218             :                 return NULL;
     219      390075 :     q->token = ENDsymbol;
     220      390075 :     q->barrier = 0;
     221      390075 :     q->argc = 0;
     222      390075 :     q->retc = 0;
     223      390075 :     q->argv[0] = 0;
     224      390075 :     pushInstruction(mb, q);
     225      390075 :         return q;
     226             : }
     227             : 
     228             : int
     229     1006628 : getIntConstant(MalBlkPtr mb, int val)
     230             : {
     231             :         int _t;
     232             :         ValRecord cst;
     233             : 
     234     1006628 :         cst.vtype= TYPE_int;
     235     1006628 :         cst.val.ival= val;
     236     1006628 :         cst.len = 0;
     237     1006628 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     238     1006628 :         if( _t < 0)
     239      426896 :                 _t = defConstant(mb, TYPE_int, &cst);
     240     1006628 :         assert(_t >= 0);
     241     1006628 :         return _t;
     242             : }
     243             : 
     244             : InstrPtr
     245    15791093 : pushInt(MalBlkPtr mb, InstrPtr q, int val)
     246             : {
     247             :         int _t;
     248             :         ValRecord cst;
     249             : 
     250    15791093 :         if (q == NULL)
     251             :                 return NULL;
     252    15791093 :         cst.vtype= TYPE_int;
     253    15791093 :         cst.val.ival= val;
     254    15791093 :         cst.len = 0;
     255    15791093 :         _t = defConstant(mb, TYPE_int, &cst);
     256    15791103 :         if( _t >= 0)
     257    15791104 :                 return pushArgument(mb, q, _t);
     258             :         return q;
     259             : }
     260             : 
     261             : int
     262           0 : getBteConstant(MalBlkPtr mb, bte val)
     263             : {
     264             :         int _t;
     265             :         ValRecord cst;
     266             : 
     267           0 :         cst.vtype= TYPE_bte;
     268           0 :         cst.val.btval= val;
     269           0 :         cst.len = 0;
     270           0 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     271           0 :         if( _t < 0)
     272           0 :                 _t = defConstant(mb, TYPE_bte, &cst);
     273           0 :         assert(_t >= 0);
     274           0 :         return _t;
     275             : }
     276             : 
     277             : InstrPtr
     278           0 : pushBte(MalBlkPtr mb, InstrPtr q, bte val)
     279             : {
     280             :         int _t;
     281             :         ValRecord cst;
     282             : 
     283           0 :         if (q == NULL)
     284             :                 return NULL;
     285           0 :         cst.vtype= TYPE_bte;
     286           0 :         cst.val.btval= val;
     287           0 :         cst.len = 0;
     288           0 :         _t = defConstant(mb, TYPE_bte,&cst);
     289           0 :         if( _t >= 0)
     290           0 :                 return pushArgument(mb, q, _t);
     291             :         return q;
     292             : }
     293             : 
     294             : int
     295           0 : getOidConstant(MalBlkPtr mb, oid val)
     296             : {
     297             :         int _t;
     298             :         ValRecord cst;
     299             : 
     300           0 :         cst.vtype= TYPE_oid;
     301           0 :         cst.val.oval= val;
     302           0 :         cst.len = 0;
     303           0 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     304           0 :         if( _t < 0)
     305           0 :                 _t = defConstant(mb, TYPE_oid, &cst);
     306           0 :         assert(_t >= 0);
     307           0 :         return _t;
     308             : }
     309             : 
     310             : InstrPtr
     311         343 : pushOid(MalBlkPtr mb, InstrPtr q, oid val)
     312             : {
     313             :         int _t;
     314             :         ValRecord cst;
     315             : 
     316         343 :         if (q == NULL)
     317             :                 return NULL;
     318         343 :         cst.vtype= TYPE_oid;
     319         343 :         cst.val.oval= val;
     320         343 :         cst.len = 0;
     321         343 :         _t = defConstant(mb,TYPE_oid,&cst);
     322         343 :         if( _t >= 0)
     323         343 :                 return pushArgument(mb, q, _t);
     324             :         return q;
     325             : }
     326             : 
     327             : InstrPtr
     328           0 : pushVoid(MalBlkPtr mb, InstrPtr q)
     329             : {
     330             :         int _t;
     331             :         ValRecord cst;
     332             : 
     333           0 :         if (q == NULL)
     334             :                 return NULL;
     335           0 :         cst.vtype= TYPE_void;
     336           0 :         cst.val.oval= oid_nil;
     337           0 :         cst.len = 0;
     338           0 :         _t = defConstant(mb,TYPE_void,&cst);
     339           0 :         if( _t >= 0)
     340           0 :                 return pushArgument(mb, q, _t);
     341             :         return q;
     342             : }
     343             : 
     344             : int
     345           0 : getLngConstant(MalBlkPtr mb, lng val)
     346             : {
     347             :         int _t;
     348             :         ValRecord cst;
     349             : 
     350           0 :         cst.vtype= TYPE_lng;
     351           0 :         cst.val.lval= val;
     352           0 :         cst.len = 0;
     353           0 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     354           0 :         if( _t < 0)
     355           0 :                 _t = defConstant(mb, TYPE_lng, &cst);
     356           0 :         assert(_t >= 0);
     357           0 :         return _t;
     358             : }
     359             : 
     360             : InstrPtr
     361    10752110 : pushLng(MalBlkPtr mb, InstrPtr q, lng val)
     362             : {
     363             :         int _t;
     364             :         ValRecord cst;
     365             : 
     366    10752110 :         if (q == NULL)
     367             :                 return NULL;
     368    10752110 :         cst.vtype= TYPE_lng;
     369    10752110 :         cst.val.lval= val;
     370    10752110 :         cst.len = 0;
     371    10752110 :         _t = defConstant(mb,TYPE_lng,&cst);
     372    10752115 :         if( _t >= 0)
     373    10752115 :                 return pushArgument(mb, q, _t);
     374             :         return q;
     375             : }
     376             : 
     377             : int
     378           0 : getShtConstant(MalBlkPtr mb, sht val)
     379             : {
     380             :         int _t;
     381             :         ValRecord cst;
     382             : 
     383           0 :         cst.vtype= TYPE_sht;
     384           0 :         cst.val.shval= val;
     385           0 :         cst.len = 0;
     386           0 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     387           0 :         if( _t < 0)
     388           0 :                 _t = defConstant(mb, TYPE_sht, &cst);
     389           0 :         assert(_t >=0);
     390           0 :         return _t;
     391             : }
     392             : 
     393             : InstrPtr
     394           0 : pushSht(MalBlkPtr mb, InstrPtr q, sht val)
     395             : {
     396             :         int _t;
     397             :         ValRecord cst;
     398             : 
     399           0 :         if (q == NULL)
     400             :                 return NULL;
     401           0 :         cst.vtype= TYPE_sht;
     402           0 :         cst.val.shval= val;
     403           0 :         cst.len = 0;
     404           0 :         _t = defConstant(mb,TYPE_sht,&cst);
     405           0 :         if( _t >= 0)
     406           0 :                 return pushArgument(mb, q, _t);
     407             :         return q;
     408             : }
     409             : 
     410             : #ifdef HAVE_HGE
     411             : int
     412           0 : getHgeConstant(MalBlkPtr mb, hge val)
     413             : {
     414             :         int _t;
     415             :         ValRecord cst;
     416             : 
     417           0 :         cst.vtype= TYPE_oid;
     418           0 :         cst.val.hval= val;
     419           0 :         cst.len = 0;
     420           0 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     421           0 :         if( _t < 0)
     422           0 :                 _t = defConstant(mb, TYPE_hge, &cst);
     423           0 :         assert(_t >= 0);
     424           0 :         return _t;
     425             : }
     426             : 
     427             : InstrPtr
     428           0 : pushHge(MalBlkPtr mb, InstrPtr q, hge val)
     429             : {
     430             :         int _t;
     431             :         ValRecord cst;
     432             : 
     433           0 :         if (q == NULL)
     434             :                 return NULL;
     435           0 :         cst.vtype= TYPE_hge;
     436           0 :         cst.val.hval= val;
     437           0 :         cst.len = 0;
     438           0 :         _t = defConstant(mb,TYPE_hge,&cst);
     439           0 :         if (_t >= 0)
     440           0 :                 return pushArgument(mb, q, _t);
     441             :         return q;
     442             : }
     443             : #endif
     444             : 
     445             : int
     446           0 : getDblConstant(MalBlkPtr mb, dbl val)
     447             : {
     448             :         int _t;
     449             :         ValRecord cst;
     450             : 
     451           0 :         cst.vtype= TYPE_dbl;
     452           0 :         cst.val.dval= val;
     453           0 :         cst.len = 0;
     454           0 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     455           0 :         if( _t < 0)
     456           0 :                 _t = defConstant(mb, TYPE_dbl, &cst);
     457           0 :         assert(_t >= 0);
     458           0 :         return _t;
     459             : }
     460             : 
     461             : InstrPtr
     462           0 : pushDbl(MalBlkPtr mb, InstrPtr q, dbl val)
     463             : {
     464             :         int _t;
     465             :         ValRecord cst;
     466             : 
     467           0 :         if (q == NULL)
     468             :                 return NULL;
     469           0 :         cst.vtype= TYPE_dbl;
     470           0 :         cst.val.dval= val;
     471           0 :         cst.len = 0;
     472           0 :         _t = defConstant(mb,TYPE_dbl,&cst);
     473           0 :         if( _t >= 0)
     474           0 :                 return pushArgument(mb, q, _t);
     475             :         return q;
     476             : }
     477             : 
     478             : int
     479           0 : getFltConstant(MalBlkPtr mb, flt val)
     480             : {
     481             :         int _t;
     482             :         ValRecord cst;
     483             : 
     484           0 :         cst.vtype= TYPE_flt;
     485           0 :         cst.val.fval= val;
     486           0 :         cst.len = 0;
     487           0 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     488           0 :         if( _t < 0)
     489           0 :                 _t = defConstant(mb, TYPE_flt, &cst);
     490           0 :         assert(_t >= 0);
     491           0 :         return _t;
     492             : }
     493             : 
     494             : InstrPtr
     495           0 : pushFlt(MalBlkPtr mb, InstrPtr q, flt val)
     496             : {
     497             :         int _t;
     498             :         ValRecord cst;
     499             : 
     500           0 :         if (q == NULL)
     501             :                 return NULL;
     502           0 :         cst.vtype= TYPE_flt;
     503           0 :         cst.val.fval= val;
     504           0 :         cst.len = 0;
     505           0 :         _t = defConstant(mb,TYPE_flt,&cst);
     506           0 :         if( _t >= 0)
     507           0 :                 return pushArgument(mb, q, _t);
     508             :         return q;
     509             : }
     510             : 
     511             : int
     512     3768926 : getStrConstant(MalBlkPtr mb, str val)
     513             : {
     514             :         int _t;
     515             :         ValRecord cst;
     516             : 
     517     3768926 :         cst.vtype = TYPE_str;
     518     3768926 :         cst.val.sval = val;
     519     3768926 :         cst.len = strlen(val);
     520     3768926 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     521     3768927 :         if( _t < 0) {
     522     1030556 :                 if ((cst.val.sval= GDKstrdup(val)) == NULL)
     523             :                         return -1;
     524     1030556 :                 _t = defConstant(mb, TYPE_str, &cst);
     525             :         }
     526     3768927 :         assert(_t >= 0);
     527             :         return _t;
     528             : }
     529             : 
     530             : InstrPtr
     531     2720963 : pushStr(MalBlkPtr mb, InstrPtr q, const char *Val)
     532             : {
     533             :         int _t;
     534             :         ValRecord cst;
     535             : 
     536     2720963 :         if (q == NULL)
     537             :                 return NULL;
     538     2720963 :         cst.vtype= TYPE_str;
     539     2720963 :         if ((cst.val.sval= GDKstrdup(Val)) == NULL) {
     540           0 :                 str msg = createException(MAL, "pushStr", "Can not allocate string variable");
     541           0 :                 addMalException(mb, msg);
     542           0 :                 freeException(msg);
     543             :         } else{
     544     2720964 :                 cst.len = strlen(cst.val.sval);
     545     2720964 :                 _t = defConstant(mb,TYPE_str,&cst);
     546     2720964 :                 if( _t >= 0)
     547     2720964 :                         return pushArgument(mb, q, _t);
     548             :         }
     549             :         return q;
     550             : }
     551             : 
     552             : int
     553           0 : getBitConstant(MalBlkPtr mb, bit val)
     554             : {
     555             :         int _t;
     556             :         ValRecord cst;
     557             : 
     558           0 :         cst.vtype= TYPE_bit;
     559           0 :         cst.val.btval= val;
     560           0 :         cst.len = 0;
     561           0 :         _t= fndConstant(mb, &cst, MAL_VAR_WINDOW);
     562           0 :         if( _t < 0)
     563           0 :                 _t = defConstant(mb, TYPE_bit, &cst);
     564           0 :         assert(_t >= 0);
     565           0 :         return _t;
     566             : }
     567             : 
     568             : InstrPtr
     569     1085214 : pushBit(MalBlkPtr mb, InstrPtr q, bit val)
     570             : {
     571             :         int _t;
     572             :         ValRecord cst;
     573             : 
     574     1085214 :         if (q == NULL)
     575             :                 return NULL;
     576     1085214 :         cst.vtype= TYPE_bit;
     577     1085214 :         cst.val.btval= val;
     578     1085214 :         cst.len = 0;
     579     1085214 :         _t = defConstant(mb,TYPE_bit,&cst);
     580     1085214 :         if( _t >= 0)
     581     1085214 :                 return pushArgument(mb, q, _t);
     582             :         return q;
     583             : }
     584             : 
     585             : InstrPtr
     586      880102 : pushNil(MalBlkPtr mb, InstrPtr q, int tpe)
     587             : {
     588             :         int _t;
     589             :         ValRecord cst;
     590             : 
     591      880102 :         if (q == NULL)
     592             :                 return NULL;
     593      880102 :         cst.len = 0;
     594      880102 :         if( !isaBatType(tpe) && tpe != TYPE_bat ) {
     595      310549 :                 assert(tpe < MAXATOMS);      /* in particular, tpe!=TYPE_any */
     596      310549 :                 if (!tpe) {
     597         680 :                         cst.vtype=TYPE_void;
     598         680 :                         cst.val.oval= oid_nil;
     599      309869 :                 } else if (ATOMextern(tpe)) {
     600       46299 :                         ptr p = ATOMnil(tpe);
     601       46299 :                         if( p == NULL){
     602           0 :                                 str msg = createException(MAL, "pushNil", "Can not allocate nil variable");
     603           0 :                                 addMalException(mb, msg);
     604           0 :                                 freeException(msg);
     605             :                         } else
     606       46299 :                                 VALset(&cst, tpe, p);
     607             :                 } else {
     608      263570 :                         if (VALinit(&cst, tpe, ATOMnilptr(tpe)) == NULL) {
     609           0 :                                 str msg =  createException(MAL, "pushNil", "Can not allocate nil variable");
     610           0 :                                 addMalException(mb, msg);
     611           0 :                                 freeException(msg);
     612             :                         }
     613             :                 }
     614      310549 :                 _t = defConstant(mb,tpe,&cst);
     615             :         } else {
     616      569553 :                 cst.vtype = TYPE_bat;
     617      569553 :                 cst.val.bval = bat_nil;
     618      569553 :                 _t = defConstant(mb,TYPE_bat,&cst);
     619      569553 :                 getVarType(mb,_t) = tpe;
     620             :         }
     621      880102 :         if( _t >= 0){
     622      880102 :                 q= pushArgument(mb, q, _t);
     623             :         }
     624             :         return q;
     625             : }
     626             : 
     627             : InstrPtr
     628           0 : pushNilType(MalBlkPtr mb, InstrPtr q, char *tpe)
     629             : {
     630             :         int _t,idx;
     631             :         ValRecord cst;
     632             :         str msg;
     633             : 
     634           0 :         if (q == NULL)
     635             :                 return NULL;
     636           0 :         idx= getAtomIndex(tpe, strlen(tpe), TYPE_any);
     637           0 :         if( idx < 0 || idx >= GDKatomcnt || idx >= MAXATOMS){
     638           0 :                 str msg = createException(MAL, "pushNilType", "Can not allocate type variable");
     639           0 :                 addMalException(mb, msg);
     640           0 :                 freeException(msg);
     641             :         } else {
     642           0 :                 cst.vtype=TYPE_void;
     643           0 :                 cst.val.oval= oid_nil;
     644           0 :                 cst.len = 0;
     645           0 :                 msg = convertConstant(idx, &cst);
     646           0 :                 if (msg != MAL_SUCCEED) {
     647           0 :                         addMalException(mb, msg);
     648           0 :                         freeException(msg);
     649             :                 } else {
     650           0 :                         _t = defConstant(mb,idx,&cst);
     651           0 :                         if( _t >= 0){
     652           0 :                                 return pushArgument(mb, q, _t);
     653             :                         }
     654             :                 }
     655             :         }
     656             :         return q;
     657             : }
     658             : 
     659             : InstrPtr
     660      331424 : pushType(MalBlkPtr mb, InstrPtr q, int tpe)
     661             : {
     662             :         int _t;
     663             :         ValRecord cst;
     664             :         str msg;
     665             : 
     666      331424 :         if (q == NULL)
     667             :                 return NULL;
     668      331424 :         cst.vtype=TYPE_void;
     669      331424 :         cst.val.oval= oid_nil;
     670      331424 :         cst.len = 0;
     671      331424 :         msg = convertConstant(tpe, &cst);
     672      331424 :         if (msg != MAL_SUCCEED){
     673           0 :                 addMalException(mb, msg);
     674           0 :                 freeException(msg);
     675             :         } else {
     676      331424 :                 _t = defConstant(mb,tpe,&cst);
     677      331424 :                 if( _t >= 0){
     678      331424 :                         return pushArgument(mb, q, _t);
     679             :                 }
     680             :         }
     681             :         return q;
     682             : }
     683             : 
     684             : InstrPtr
     685           0 : pushZero(MalBlkPtr mb, InstrPtr q, int tpe)
     686             : {
     687             :         int _t;
     688             :         ValRecord cst;
     689             :         str msg;
     690             : 
     691           0 :         if (q == NULL)
     692             :                 return NULL;
     693           0 :         cst.vtype=TYPE_int;
     694           0 :         cst.val.ival= 0;
     695           0 :         cst.len = 0;
     696           0 :         msg = convertConstant(tpe, &cst);
     697           0 :         if (msg != MAL_SUCCEED) {
     698           0 :                 addMalException(mb, msg);
     699           0 :                 freeException(msg);
     700             :         } else {
     701           0 :                 _t = defConstant(mb,tpe,&cst);
     702           0 :                 if( _t >= 0)
     703           0 :                         return pushArgument(mb, q, _t);
     704             :         }
     705             :         return q;
     706             : }
     707             : 
     708             : InstrPtr
     709           0 : pushEmptyBAT(MalBlkPtr mb, InstrPtr q, int tpe)
     710             : {
     711           0 :         if (q == NULL)
     712             :                 return NULL;
     713           0 :         setModuleId(q, getName("bat"));
     714           0 :         setFunctionId(q, getName("new"));
     715             : 
     716           0 :         q = pushArgument(mb, q, newTypeVariable(mb,TYPE_void));
     717           0 :         q = pushArgument(mb, q, newTypeVariable(mb,getBatType(tpe)));
     718           0 :         q = pushZero(mb,q,TYPE_lng);
     719           0 :         return q;
     720             : }
     721             : 
     722             : InstrPtr
     723           1 : pushValue(MalBlkPtr mb, InstrPtr q, ValPtr vr)
     724             : {
     725             :         int _t;
     726             :         ValRecord cst;
     727             : 
     728           1 :         if (q == NULL)
     729             :                 return NULL;
     730           1 :         if (VALcopy(&cst, vr) == NULL) {
     731           0 :                 str msg = createException(MAL, "pushValue", "Can not allocate variable");
     732           0 :                 addMalException(mb, msg);
     733           0 :                 freeException(msg);
     734             :         } else {
     735           1 :                 _t = defConstant(mb,cst.vtype,&cst);
     736           1 :                 if( _t >=0 )
     737           1 :                         return pushArgument(mb, q, _t);
     738             :         }
     739             :         return q;
     740             : }

Generated by: LCOV version 1.14