path: root/misc/pascal/insn32/include/builtins.h

/***********************************************************************
 * builtins.h
 * Definitions of built-in function calls.
 *
 *   Copyright (C) 2008 Gregory Nutt. All rights reserved.
 *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name NuttX nor the names of its contributors may be
 *    used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 ***********************************************************************/

#ifndef __BUILTINS_H
#define __BUILTINS_H

/***********************************************************************
 * Definitions
 ***********************************************************************/

#define MAX_BUILTIN_ARGS 3

#define ILLEGAL_BUILTIN_INIT \
    { NULL, 0, 0, { 0 }}

/* SYSIO built-ins ****************y*************************************/

/* boolean _xeof(fileno); */
#define xEOF_INIT \
    { "_xeof", sBOOLEAN_SIZE, 1, { sINT_SIZE }}

/* boolean _xeoln(fileno); */
#define xEOLN_INIT \
    { "_xeoln", sBOOLEAN_SIZE, 1, { sINT_SIZE }}

/* void _xreset(int fileno); */
#define xRESET_INIT \
    { "_xreset", 0, 1, { sINT_SIZE }}

/* void _xrewrite(int fileno); */
#define xREWRITE_INIT \
    { "_xrewrite", 0, 1, { sINT_SIZE }}

/* void _xreadln(int fileno); */
#define xREADLN_INIT \
    { "_xreadln", 0, 1, { sINT_SIZE }}

#define xREAD_PAGE_INIT ILLEGAL_BUILTIN_INIT

/* void _xread_binary(int fileno, char *buffer, int buffersize); */
#define xREAD_BINARY_INIT \
    { "_xread_binary", 0, 3, { sINT_SIZE, sPTR_SIZE, sINT_SIZE }}

/* void _xread_int(int fileno, int *value); */
#define xREAD_INT_INIT \
    { "_xread_int", 0, 2, { sINT_SIZE, sPTR_SIZE }}

/* void _xread_char(int fileno, char *value); */
#define xREAD_CHAR_INIT \
    { "_xread_char", 0, 2, { sINT_SIZE, sPTR_SIZE }}

/* void _xread_string(int fileno, char *string, int stringsize); */
#define xREAD_STRING_INIT \
    { "_xread_string", 0, 3, { sINT_SIZE, sPTR_SIZE, sINT_SIZE }}

/* void _xread_real(int fileno, real *value); */
#define xREAD_REAL_INIT \
    { "_xread_real", 0, 2, { sINT_SIZE, sPTR_SIZE }}

/* void _xwriteln(int fileno); */
#define xWRITELN_INIT \
    { "_xwriteln", 0, 1, { sINT_SIZE }}

/* void _xwrite_page(int fileno); */
#define xWRITE_PAGE_INIT \
    { "_xwrite_page", 0, 1, { sINT_SIZE }}

/* void _write_binary(int fileno, char *buffer, int buffersize); */
#define xWRITE_BINARY_INIT \
    { "_xwrite_binary", 0, 3, { sINT_SIZE, sPTR_SIZE, sINT_SIZE }}

/* void _write_int(int fileno, int value); */
#define xWRITE_INT_INIT \
    { "_xwrite_int", 0, 2, { sINT_SIZE, sINT_SIZE }}

/* void _write_char(int fileno, int value); */
#define xWRITE_CHAR_INIT \
    { "_xwrite_char", 0, 2, { sINT_SIZE, sINT_SIZE }}

/* void _write_string(int fileno, char *string, int stringsize); */
#define xWRITE_STRING_INIT \
    { "_xwrite_string", 0, 3, { sINT_SIZE, sPTR_SIZE, sINT_SIZE }}

/* void _write_real(int fileno, real value); */
#define xWRITE_REAL_INIT \
    { "_xwrite_real", 0, 2, { sINT_SIZE, sREAL_SIZE }}

/* Runtime library built-ins *******************************************/
/* string _lbgetenv(string *name); */
#define lbGETENV_INIT \
    { "_lbgetenv", sRSTRING_SIZE, 1, { sRSTRING_SIZE }}

/* void _lbstr2str(string src, string dest); */
#define lbSTR2STR_INIT \
    { "_lbstgr2str", 0, 2, { sRSTRING_SIZE, sRSTRING_SIZE }}

/* void _lbcstr2str(string src, string dest); */
#define lbCSTR2STR_INIT \
    { "_lbcstr2str", 0, 2, { sRSTRING_SIZE, sRSTRING_SIZE }}

/* void _libstr2rstr(string src, string dest); */
#define lbSTR2RSTR_INIT \
    { "_lbstr2rstr", 0, 2, { sRSTRING_SIZE, sRSTRING_SIZE }}

/* void _lbcstr2str(string src, string dest); */
#define lbCSTR2RSTR_INIT \
    { "_lbcstr2rstr", 0, 2, { sRSTRING_SIZE, sRSTRING_SIZE }}

/* void _lbval(const string s, int *v, int *code); */
#define lbVAL_INIT \
    { "_lbval", 0, 2, { sRSTRING_SIZE, sPTR_SIZE, sPTR_SIZE }}

/* string _lbmkstk(void); */
#define lbMKSTK_INIT \
    { "_lbmkstk",  sRSTRING_SIZE, 0, { 0 }}

/* string mkstkstr(string name); */
#define lbMKSTKSTR_INIT \
    { "_lbmkstkstr",  sRSTRING_SIZE, 1, { sRSTRING_SIZE }}

/* string _lbmkstkc(int c); */
#define lbMKSTKC_INIT \
    { "_lbmkstkc",  sRSTRING_SIZE, 1, { sINT_SIZE }}

/* string _lbstgrcat(string name, int c); */
#define lbSTRCAT_INIT \
    { "_lbstrcat",  sRSTRING_SIZE, 2, { sRSTRING_SIZE, sINT_SIZE }}

/* string _lbstrcatc(string name, int c); */
#define lbSTRCATC_INIT \
    { "_lbstrcatc",  sRSTRING_SIZE, 2, { sRSTRING_SIZE, sINT_SIZE }}

/* int _lbstrcmp(string name1, string name2); */
#define lbSTRCMP_INIT \
    { "_lbstrcmp", sINT_SIZE, 2, { sRSTRING_SIZE, sRSTRING_SIZE }}

/* Floating point library built-ins ************************************/

/* real _fpfloat(int v); */
#define fpFLOAT_INIT \
    { "_fpfloat", sREAL_SIZE, 1, { sINT_SIZE }}

/* int _fptrunc(real v); */
#define fpTRUNC_INIT \
    { "_fptrunc", sINT_SIZE, 1, { sREAL_SIZE }}

/* int _fpround(real v); */
#define fpROUND_INIT \
    { "_fpround", sINT_SIZE, 1, { sREAL_SIZE }}

/* real _fpadd_rr(real a, real b); */
#define fpADD_RR_INIT \
    { "_fpadd_rr", sREAL_SIZE, 2, { sREAL_SIZE, sREAL_SIZE }}

/* real _fpadd_ri(int a, real b); */
#define fpADD_RI_INIT \
    { "_fpadd_ri", sREAL_SIZE, 2, { sINT_SIZE, sREAL_SIZE }}

/* real _fpadd_ir(real a, int b); */
#define fpADD_IR_INIT \
    { "_fpadd_ir", sREAL_SIZE, 2, { sREAL_SIZE, sINT_SIZE }}

/* real _fpadd_ii(int a, int b); */
#define fpADD_II_INIT \
    { "_fpadd_ii", sREAL_SIZE, 2, { sINT_SIZE, sINT_SIZE }}

/* real _fpsub_rr(real a, real b); */
#define fpSUB_RR_INIT \
    { "_fpsub_rr", sREAL_SIZE, 2, { sREAL_SIZE, sREAL_SIZE }}

/* real _fpsub_ri(int a, real b); */
#define fpSUB_RI_INIT \
    { "_fpsub_ri", sREAL_SIZE, 2, { sINT_SIZE, sREAL_SIZE }}

/* real _fpsub_ir(real a, int b); */
#define fpSUB_IR_INIT \
    { "_fpsub_ir", sREAL_SIZE, 2, { sREAL_SIZE, sINT_SIZE }}

/* real _fpsub_ii(int a, int b); */
#define fpSUB_II_INIT \
    { "_fpsub_ii", sREAL_SIZE, 2, { sINT_SIZE, sINT_SIZE }}

/* real _fpmul_rr(real a, real b); */
#define fpMUL_RR_INIT \
    { "_fpmul_rr", sREAL_SIZE, 2, { sREAL_SIZE, sREAL_SIZE }}

/* real _fpmul_ri(int a, real b); */
#define fpMUL_RI_INIT \
    { "_fpmul_ri", sREAL_SIZE, 2, { sINT_SIZE, sREAL_SIZE }}

/* real _fpmul_ir(real a, int b); */
#define fpMUL_IR_INIT \
    { "_fpmul_ir",sREAL_SIZE, 2, { sREAL_SIZE, sINT_SIZE }}

/* real _fpmul_ii(int a, int b); */
#define fpMUL_II_INIT \
    { "_fpmul_ii", sREAL_SIZE, 2, { sINT_SIZE, sINT_SIZE }}

/* real _fpdiv_rr(real a, real b); */
#define fpDIV_RR_INIT \
    { "_fpdiv_rr", sREAL_SIZE, 2, { sREAL_SIZE, sREAL_SIZE }}

/* real _fpdiv_ri(int a, real b); */
#define fpDIV_RI_INIT \
    { "_fpdiv_ri",sREAL_SIZE, 2, { sINT_SIZE, sREAL_SIZE }}

/* real _fpdiv_ir(real a, int b); */
#define fpDIV_IR_INIT \
    { "_fpdiv_ir",sREAL_SIZE, 2, { sREAL_SIZE, sINT_SIZE }}

/* real _fpdiv_ii(int a, int b); */
#define fpDIV_II_INIT \
    { "_fpdiv_ii",sREAL_SIZE, 2, { sINT_SIZE, sINT_SIZE }}

/* real _fpmod_rr(real a, real b); */
#define fpMOD_RR_INIT \
    { "_fpmod_rr", sREAL_SIZE, 2, { sREAL_SIZE, sREAL_SIZE }}

/* real _fpmod_ri(int a, real b); */
#define fpMOD_RI_INIT \
    { "_fpmod_ri", sREAL_SIZE, 2, { sINT_SIZE, sREAL_SIZE }}

/* real _fpmod_ir(real a, int b); */
#define fpMOD_IR_INIT \
    { "_fpmod_ir", sREAL_SIZE, 2, { sREAL_SIZE, sINT_SIZE }}

/* real _fpmod_ii(int a, int b); */
#define fpMOD_II_INIT \
    { "_fpmod_ii", sREAL_SIZE, 2, { sINT_SIZE, sINT_SIZE }}

/* boolean _fpequ_rr(real a, real b); */
#define fpEQU_RR_INIT \
    { "_fpequ_rr", sBOOLEAN_SIZE, 2, { sREAL_SIZE, sREAL_SIZE }}

/* boolean _fpequ_ri(int a, real b); */
#define fpEQU_RI_INIT \
    { "_fpequ_ri", sBOOLEAN_SIZE, 2, { sINT_SIZE, sREAL_SIZE }}

/* boolean _fpequ_ir(real a, int b); */
#define fpEQU_IR_INIT \
    { "_fpequ_ir", sBOOLEAN_SIZE, 2, { sREAL_SIZE, sINT_SIZE }}

/* boolean _fpequ_ii(int a, int b); */
#define fpEQU_II_INIT \
    { "_fpequ_ii", sBOOLEAN_SIZE, 2, { sINT_SIZE, sINT_SIZE }}

/* boolean _fpneq_rr(real a, real b); */
#define fpNEQ_RR_INIT \
    { "_fpneq_rr", sBOOLEAN_SIZE, 2, { sREAL_SIZE, sREAL_SIZE }}

/* boolean _fpneq_ri(int a, real b); */
#define fpNEQ_RI_INIT \
    { "_fpneq_ri", sBOOLEAN_SIZE, 2, { sINT_SIZE, sREAL_SIZE }}

/* boolean _fpneq_ir(real a, int b); */
#define fpNEQ_IR_INIT \
    { "_fpneq_ir", sBOOLEAN_SIZE, 2, { sREAL_SIZE, sINT_SIZE }}

/* boolean _fpneq_ii(int a, int b); */
#define fpNEQ_II_INIT \
    { "_fpneq_ii", sBOOLEAN_SIZE, 2, { sINT_SIZE, sINT_SIZE }}

/* boolean _fplt_rr(real a, real b); */
#define fpLT_RR_INIT \
    { "_fplt_rr", sBOOLEAN_SIZE, 2, { sREAL_SIZE, sREAL_SIZE }}

/* boolean _fplt_ri(int a, real b); */
#define fpLT_RI_INIT \
    { "_fplt_ri", sBOOLEAN_SIZE, 2, { sINT_SIZE, sREAL_SIZE }}

/* boolean _fplt_ir(real a, int b); */
#define fpLT_IR_INIT \
    { "_fplt_ir", sBOOLEAN_SIZE, 2, { sREAL_SIZE, sINT_SIZE }}

/* boolean _fplt_ii(int a, int b); */
#define fpLT_II_INIT \
    { "_fplt_ii", sBOOLEAN_SIZE, 2, { sINT_SIZE, sINT_SIZE }}

/* boolean _fpgte_rr(real a, real b); */
#define fpGTE_RR_INIT \
    { "_fpgte_rr", sBOOLEAN_SIZE, 2, { sREAL_SIZE, sREAL_SIZE }}

/* boolean _fpgte_ri(int a, real b); */
#define fpGTE_RI_INIT \
    { "_fpgte_ri", sBOOLEAN_SIZE, 2, { sINT_SIZE, sREAL_SIZE }}

/* boolean _fpgte_ir(real a, int b); */
#define fpGTE_IR_INIT \
    { "_fpgte_ir", sBOOLEAN_SIZE, 2, { sREAL_SIZE, sINT_SIZE }}

/* boolean _fpgte_ii(int a, int b); */
#define fpGTE_II_INIT \
    { "_fpgte_ii", sBOOLEAN_SIZE, 2, { sINT_SIZE, sINT_SIZE }}

/* boolean _fpgt_rr(real a, real b); */
#define fpGT_RR_INIT \
    { "_fpgt_rr", sBOOLEAN_SIZE, 2, { sREAL_SIZE, sREAL_SIZE }}

/* boolean _fpgt_ri(int a, real b); */
#define fpGT_RI_INIT \
    { "_fpgt_ri", sBOOLEAN_SIZE, 2, { sINT_SIZE, sREAL_SIZE }}

/* boolean _fpgt_ir(real a, int b); */
#define fpGT_IR_INIT \
    { "_fpgt_ir", sBOOLEAN_SIZE, 2, { sREAL_SIZE, sINT_SIZE }}

/* boolean _fpgt_ii(int a, int b); */
#define fpGT_II_INIT \
    { "_fpgt_ii", sBOOLEAN_SIZE, 2, { sINT_SIZE, sINT_SIZE }}

/* boolean _fplte_rr(real a, real b); */
#define fpLTE_RR_INIT \
    { "_fplte_rr", sBOOLEAN_SIZE, 2, { sREAL_SIZE, sREAL_SIZE }}

/* boolean _fplte_ri(int a, real b); */
#define fpLTE_RI_INIT \
    { "_fplte_ri", sBOOLEAN_SIZE, 2, { sINT_SIZE, sREAL_SIZE }}

/* boolean _fplte_ir(real a, int b); */
#define fpLTE_IR_INIT \
    { "_fplte_ir", sBOOLEAN_SIZE, 2, { sREAL_SIZE, sINT_SIZE }}

/* boolean _fplte_ii(int a, int b); */
#define fpLTE_II_INIT \
    { "_fplte_ii", sBOOLEAN_SIZE, 2, { sINT_SIZE, sINT_SIZE }}

/* real _fpneg_r(real v); */
#define fpNEG_R_INIT \
    { "_fpneg_r", sREAL_SIZE, 1, { sREAL_SIZE }}

/* real _fpneg_i(int v); */
#define fpNEG_I_INIT \
    { "_fpneg_i", sREAL_SIZE, 1, { sINT_SIZE }}

/* real _fpabs_r(real v); */
#define fpABS_R_INIT \
    { "_fpabs_r", sREAL_SIZE, 1, { sREAL_SIZE }}

/* real _fpabs_i(int v); */
#define fpABS_I_INIT \
    { "_fpabs_i", sREAL_SIZE, 1, { sINT_SIZE }}

/* real _fpsqr_r(real v); */
#define fpSQR_R_INIT \
    { "_fpsqr_r", sREAL_SIZE, 1, { sREAL_SIZE }}

/* real _fpsqr_i(int v); */
#define fpSQR_I_INIT \
    { "_fpsqr_i", sREAL_SIZE, 1, { sINT_SIZE }}

/* real _fpsqrt_r(real v); */
#define fpSQRT_R_INIT \
    { "_fpsqrt_r", sREAL_SIZE, 1, { sREAL_SIZE }}

/* real _fpsqrt_i(int v); */
#define fpSQRT_I_INIT \
    { "_fpsqrt_i", sREAL_SIZE, 1, { sINT_SIZE }}

/* real _fpsin_r(real v); */
#define fpSIN_R_INIT \
    { "_fpsin_r", sREAL_SIZE, 1, { sREAL_SIZE }}

/* real _fpsin_i(int v); */
#define fpSIN_I_INIT \
    { "_fpsin_i", sREAL_SIZE, 1, { sINT_SIZE }}

/* real _fpcos_r(real v); */
#define fpCOS_R_INIT \
    { "_fpcos_r", sREAL_SIZE, 1, { sREAL_SIZE }}

/* real _fpcos_i(int v); */
#define fpCOS_I_INIT \
    { "_fpcos_i", sREAL_SIZE, 1, { sINT_SIZE }}

/* real _fpatan_r(real v); */
#define fpATAN_R_INIT \
    { "_fpatan_r", sREAL_SIZE, 1, { sREAL_SIZE }}

/* real _fpatan_i(int v); */
#define fpATAN_I_INIT \
    { "_fpatan_i", sREAL_SIZE, 1, { sINT_SIZE }}

/* real _fpln_r(real v); */
#define fpLN_R_INIT \
    { "_fpln_r", sREAL_SIZE, 1, { sREAL_SIZE }}

/* real _fpln_i(int v); */
#define fpLN_I_INIT \
    { "_fpln_i", sREAL_SIZE, 1, { sINT_SIZE }}

/* real _fpexp_r(real v); */
#define fpEXP_R_INIT \
    { "_fpexpr_r", sREAL_SIZE, 1, { sREAL_SIZE }}

/* real _fpexp_i(int v); */
#define fpEXP_I_INIT \
    { "_fpexpr_i", sREAL_SIZE, 1, { sINT_SIZE }}

/***********************************************************************
 * Public Types
 ***********************************************************************/

struct regm_builtin_s
{
  const char *szName;
  uint32      wRetSize;
  uint32      nParms;
  uint32      wArgSize[MAX_BUILTIN_ARGS];
};

#endif /* __BUILTINS_H */