2005-11-12 22:47:49 +03:00
|
|
|
#ifndef PRIVATE_SLANG_H_
|
|
|
|
#define PRIVATE_SLANG_H_
|
2002-10-07 08:41:03 +04:00
|
|
|
/* header file for S-Lang internal structures that users do not (should not)
|
|
|
|
need. Use slang.h for that purpose. */
|
2005-11-12 22:47:49 +03:00
|
|
|
/*
|
* slcommon.c, sldisplay.c, slerr.c, slgetkey.c, slmisc.c, slsignal.c,
slsmg.c, slstring.c, sltermin.c, slutty.c, include/_slang.h,
include/slang.h: Patch to slang-2.0.6 leaving local patches intact.
2006-02-15 18:10:55 +03:00
|
|
|
Copyright (C) 2004, 2005, 2006 John E. Davis
|
2005-11-12 22:47:49 +03:00
|
|
|
|
|
|
|
This file is part of the S-Lang Library.
|
|
|
|
|
|
|
|
The S-Lang Library is free software; you can redistribute it and/or
|
|
|
|
modify it under the terms of the GNU General Public License as
|
|
|
|
published by the Free Software Foundation; either version 2 of the
|
|
|
|
License, or (at your option) any later version.
|
|
|
|
|
|
|
|
The S-Lang Library is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this library; if not, write to the Free Software
|
|
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
|
|
|
USA.
|
|
|
|
*/
|
2002-10-07 08:41:03 +04:00
|
|
|
|
|
|
|
/* #include "config.h" */
|
|
|
|
#include "jdmacros.h"
|
|
|
|
#include "sllimits.h"
|
|
|
|
|
|
|
|
#ifdef VMS
|
|
|
|
# define SLANG_SYSTEM_NAME "_VMS"
|
|
|
|
#else
|
|
|
|
# if defined (IBMPC_SYSTEM)
|
|
|
|
# define SLANG_SYSTEM_NAME "_IBMPC"
|
|
|
|
# else
|
|
|
|
# define SLANG_SYSTEM_NAME "_UNIX"
|
|
|
|
# endif
|
|
|
|
#endif /* VMS */
|
|
|
|
|
|
|
|
/* These quantities are main_types for byte-compiled code. They are used
|
|
|
|
* by the inner_interp routine. The _BC_ means byte-code.
|
|
|
|
*/
|
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
/* Nametype byte-codes --- these must correspond to those in slang.h */
|
|
|
|
typedef enum
|
|
|
|
{
|
|
|
|
SLANG_BC_LAST_BLOCK = 0,
|
|
|
|
SLANG_BC_LVARIABLE = SLANG_LVARIABLE, /* 0x01 */
|
|
|
|
SLANG_BC_GVARIABLE = SLANG_GVARIABLE, /* 0x02 */
|
|
|
|
SLANG_BC_IVARIABLE = SLANG_IVARIABLE, /* 0x03 */
|
|
|
|
SLANG_BC_RVARIABLE = SLANG_RVARIABLE, /* 0x04 */
|
|
|
|
SLANG_BC_INTRINSIC = SLANG_INTRINSIC, /* 0x05 */
|
|
|
|
SLANG_BC_FUNCTION = SLANG_FUNCTION, /* 0x06 */
|
|
|
|
SLANG_BC_MATH_UNARY = SLANG_MATH_UNARY, /* 0x07 */
|
|
|
|
SLANG_BC_APP_UNARY = SLANG_APP_UNARY, /* 0x08 */
|
|
|
|
SLANG_BC_ARITH_UNARY = SLANG_ARITH_UNARY, /* 0x09 */
|
|
|
|
SLANG_BC_ARITH_BINARY = SLANG_ARITH_BINARY, /* 0x0A */
|
|
|
|
SLANG_BC_ICONST = SLANG_ICONSTANT, /* 0x0B */
|
|
|
|
SLANG_BC_DCONST = SLANG_DCONSTANT, /* 0x0C */
|
|
|
|
SLANG_BC_FCONST = SLANG_FCONSTANT, /* 0x0D */
|
|
|
|
SLANG_BC_LLCONST = SLANG_LLCONSTANT, /* 0x0E */
|
|
|
|
SLANG_BC_PVARIABLE = SLANG_PVARIABLE, /* 0x0F */
|
|
|
|
SLANG_BC_PFUNCTION = SLANG_PFUNCTION, /* 0x10 */
|
|
|
|
SLANG_BC_HCONST = SLANG_HCONSTANT, /* 0x11 */
|
|
|
|
SLANG_BC_LCONST = SLANG_LCONSTANT, /* 0x12 */
|
|
|
|
SLANG_BC_UNUSED_0x12 = 0x12,
|
|
|
|
SLANG_BC_UNUSED_0x13 = 0x13,
|
|
|
|
SLANG_BC_UNUSED_0x14 = 0x14,
|
|
|
|
SLANG_BC_UNUSED_0x15 = 0x15,
|
|
|
|
SLANG_BC_UNUSED_0x16 = 0x16,
|
|
|
|
SLANG_BC_UNUSED_0x17 = 0x17,
|
|
|
|
SLANG_BC_UNUSED_0x18 = 0x18,
|
|
|
|
SLANG_BC_UNUSED_0x19 = 0x19,
|
|
|
|
SLANG_BC_UNUSED_0x1A = 0x1A,
|
|
|
|
SLANG_BC_UNUSED_0x1B = 0x1B,
|
|
|
|
SLANG_BC_UNUSED_0x1C = 0x1C,
|
|
|
|
SLANG_BC_UNUSED_0x1D = 0x1D,
|
|
|
|
SLANG_BC_UNUSED_0x1E = 0x1E,
|
|
|
|
SLANG_BC_UNUSED_0x1F = 0x1F,
|
|
|
|
|
|
|
|
/* bytes codes for setting/assigning variables/arrays/structures/refs */
|
|
|
|
SLANG_BC_SET_LOCAL_LVALUE = 0x20,
|
|
|
|
SLANG_BC_SET_GLOBAL_LVALUE = 0x21,
|
|
|
|
SLANG_BC_SET_INTRIN_LVALUE = 0x22,
|
|
|
|
SLANG_BC_SET_STRUCT_LVALUE = 0x23,
|
|
|
|
SLANG_BC_SET_ARRAY_LVALUE = 0x24,
|
|
|
|
SLANG_BC_SET_DEREF_LVALUE = 0x25,
|
|
|
|
SLANG_BC_FIELD = 0x26,
|
|
|
|
SLANG_BC_METHOD = 0x27,
|
|
|
|
SLANG_BC_LVARIABLE_AGET = 0x28,
|
|
|
|
SLANG_BC_LVARIABLE_APUT = 0x29,
|
|
|
|
SLANG_BC_LOBJPTR = 0x2A,
|
|
|
|
SLANG_BC_GOBJPTR = 0x2B,
|
|
|
|
SLANG_BC_UNUSED_0x2C = 0x2C,
|
|
|
|
SLANG_BC_UNUSED_0x2D = 0x2D,
|
|
|
|
SLANG_BC_UNUSED_0x2E = 0x2E,
|
|
|
|
SLANG_BC_UNUSED_0x2F = 0x2F,
|
|
|
|
SLANG_BC_UNUSED_0x30 = 0x30,
|
|
|
|
SLANG_BC_UNUSED_0x31 = 0x31,
|
|
|
|
SLANG_BC_UNUSED_0x32 = 0x32,
|
|
|
|
SLANG_BC_UNUSED_0x33 = 0x33,
|
|
|
|
SLANG_BC_UNUSED_0x34 = 0x34,
|
|
|
|
SLANG_BC_UNUSED_0x35 = 0x35,
|
|
|
|
SLANG_BC_UNUSED_0x36 = 0x36,
|
|
|
|
SLANG_BC_UNUSED_0x37 = 0x37,
|
|
|
|
SLANG_BC_UNUSED_0x38 = 0x38,
|
|
|
|
SLANG_BC_UNUSED_0x39 = 0x39,
|
|
|
|
SLANG_BC_UNUSED_0x3A = 0x3A,
|
|
|
|
SLANG_BC_UNUSED_0x3B = 0x3B,
|
|
|
|
SLANG_BC_UNUSED_0x3C = 0x3C,
|
|
|
|
SLANG_BC_UNUSED_0x3D = 0x3D,
|
|
|
|
SLANG_BC_UNUSED_0x3E = 0x3E,
|
|
|
|
SLANG_BC_UNUSED_0x3F = 0x3F,
|
|
|
|
|
|
|
|
/* byte codes for literals */
|
|
|
|
SLANG_BC_LITERAL = 0x40, /* constant objects */
|
|
|
|
SLANG_BC_LITERAL_INT = 0x41,
|
|
|
|
SLANG_BC_LITERAL_DBL = 0x42,
|
|
|
|
SLANG_BC_LITERAL_STR = 0x43,
|
|
|
|
SLANG_BC_DOLLAR_STR = 0x44,
|
|
|
|
SLANG_BC_LITERAL_SHORT = 0x45,
|
|
|
|
SLANG_BC_LITERAL_LONG = 0x46,
|
|
|
|
SLANG_BC_UNUSED_0x45 = 0x45,
|
|
|
|
SLANG_BC_UNUSED_0x46 = 0x46,
|
|
|
|
SLANG_BC_UNUSED_0x47 = 0x47,
|
|
|
|
SLANG_BC_UNUSED_0x48 = 0x48,
|
|
|
|
SLANG_BC_UNUSED_0x49 = 0x49,
|
|
|
|
SLANG_BC_UNUSED_0x4A = 0x4A,
|
|
|
|
SLANG_BC_UNUSED_0x4B = 0x4B,
|
|
|
|
SLANG_BC_UNUSED_0x4C = 0x4C,
|
|
|
|
SLANG_BC_UNUSED_0x4D = 0x4D,
|
|
|
|
SLANG_BC_UNUSED_0x4E = 0x4E,
|
|
|
|
SLANG_BC_UNUSED_0x4F = 0x4F,
|
|
|
|
|
|
|
|
/* Unary/Binary operation codes */
|
|
|
|
SLANG_BC_UNARY = 0x50,
|
|
|
|
SLANG_BC_BINARY = 0x51,
|
|
|
|
SLANG_BC_INTEGER_PLUS = 0x52,
|
|
|
|
SLANG_BC_INTEGER_MINUS = 0x53,
|
|
|
|
SLANG_BC_UNUSED_0x54 = 0x54,
|
|
|
|
SLANG_BC_UNUSED_0x55 = 0x55,
|
|
|
|
SLANG_BC_UNUSED_0x56 = 0x56,
|
|
|
|
SLANG_BC_UNUSED_0x57 = 0x57,
|
|
|
|
SLANG_BC_UNUSED_0x58 = 0x58,
|
|
|
|
SLANG_BC_UNUSED_0x59 = 0x59,
|
|
|
|
SLANG_BC_UNUSED_0x5A = 0x5A,
|
|
|
|
SLANG_BC_UNUSED_0x5B = 0x5B,
|
|
|
|
SLANG_BC_UNUSED_0x5C = 0x5C,
|
|
|
|
SLANG_BC_UNUSED_0x5D = 0x5D,
|
|
|
|
SLANG_BC_UNUSED_0x5E = 0x5E,
|
|
|
|
SLANG_BC_UNUSED_0x5F = 0x5F,
|
|
|
|
|
|
|
|
/* byte codes associated with keywords and blocks */
|
|
|
|
SLANG_BC_TMP = 0x60,
|
|
|
|
SLANG_BC_EXCH = 0x61,
|
|
|
|
SLANG_BC_LABEL = 0x62,
|
|
|
|
SLANG_BC_BLOCK = 0x63,
|
|
|
|
SLANG_BC_RETURN = 0x64,
|
|
|
|
SLANG_BC_BREAK = 0x65,
|
|
|
|
SLANG_BC_CONTINUE = 0x66,
|
|
|
|
SLANG_BC_IF_BLOCK = 0x67, /* optimized code */
|
|
|
|
SLANG_BC_UNUSED_0x68 = 0x68,
|
|
|
|
SLANG_BC_UNUSED_0x69 = 0x69,
|
|
|
|
SLANG_BC_X_ERROR = 0x6A,
|
|
|
|
SLANG_BC_X_USER0 = 0x6B,
|
|
|
|
SLANG_BC_X_USER1 = 0x6C,
|
|
|
|
SLANG_BC_X_USER2 = 0x6D,
|
|
|
|
SLANG_BC_X_USER3 = 0x6E,
|
|
|
|
SLANG_BC_X_USER4 = 0x6F,
|
|
|
|
|
|
|
|
/* byte codes for dealing with the frame pointer and arg list */
|
|
|
|
SLANG_BC_CALL_DIRECT = 0x70,
|
|
|
|
SLANG_BC_CALL_DIRECT_FRAME = 0x71,
|
|
|
|
/* SLANG_BC_ARG_LVARIABLE = 0x72, */
|
|
|
|
SLANG_BC_UNUSED_0x72 = 0x72,
|
|
|
|
SLANG_BC_EARG_LVARIABLE = 0x73,
|
|
|
|
SLANG_BC_LINE_NUM = 0x74,
|
|
|
|
SLANG_BC_BOS = 0x75,
|
|
|
|
SLANG_BC_EOS = 0x76,
|
|
|
|
SLANG_BC_UNUSED_0x77 = 0x77,
|
|
|
|
SLANG_BC_UNUSED_0x78 = 0x78,
|
|
|
|
SLANG_BC_UNUSED_0x79 = 0x79,
|
|
|
|
SLANG_BC_UNUSED_0x7A = 0x7A,
|
|
|
|
SLANG_BC_UNUSED_0x7B = 0x7B,
|
|
|
|
SLANG_BC_UNUSED_0x7C = 0x7C,
|
|
|
|
SLANG_BC_UNUSED_0x7D = 0x7D,
|
|
|
|
SLANG_BC_UNUSED_0x7E = 0x7E,
|
|
|
|
SLANG_BC_UNUSED_0x7F = 0x7F,
|
|
|
|
|
|
|
|
/* These are used only when compiled with USE_COMBINED_BYTECODES */
|
|
|
|
SLANG_BC_CALL_DIRECT_INTRINSIC= 0x80,
|
|
|
|
SLANG_BC_INTRINSIC_CALL_DIRECT= 0x81,
|
|
|
|
SLANG_BC_CALL_DIRECT_LSTR = 0x82,
|
|
|
|
SLANG_BC_CALL_DIRECT_SLFUN = 0x83,
|
|
|
|
SLANG_BC_CALL_DIRECT_RETINTR = 0x84,
|
|
|
|
SLANG_BC_RET_INTRINSIC = 0x85,
|
|
|
|
SLANG_BC_CALL_DIRECT_EARG_LVAR= 0x86,
|
|
|
|
SLANG_BC_CALL_DIRECT_LINT = 0x87,
|
|
|
|
SLANG_BC_CALL_DIRECT_LVAR = 0x88,
|
|
|
|
SLANG_BC_LLVARIABLE_BINARY = 0x89,
|
|
|
|
SLANG_BC_LGVARIABLE_BINARY = 0x8A,
|
|
|
|
SLANG_BC_GLVARIABLE_BINARY = 0x8B,
|
|
|
|
SLANG_BC_GGVARIABLE_BINARY = 0x8C,
|
|
|
|
SLANG_BC_LIVARIABLE_BINARY = 0x8D,
|
|
|
|
SLANG_BC_LDVARIABLE_BINARY = 0x8E,
|
|
|
|
SLANG_BC_ILVARIABLE_BINARY = 0x8F,
|
|
|
|
SLANG_BC_DLVARIABLE_BINARY = 0x90,
|
|
|
|
SLANG_BC_LVARIABLE_BINARY = 0x91,
|
|
|
|
SLANG_BC_GVARIABLE_BINARY = 0x92,
|
|
|
|
SLANG_BC_LITERAL_INT_BINARY = 0x93,
|
|
|
|
SLANG_BC_LITERAL_DBL_BINARY = 0x94,
|
|
|
|
SLANG_BC_LASSIGN_LLBINARY = 0x95,
|
|
|
|
SLANG_BC_LASSIGN_LIBINARY = 0x96,
|
|
|
|
SLANG_BC_LASSIGN_ILBINARY = 0x97,
|
|
|
|
SLANG_BC_LASSIGN_LDBINARY = 0x98,
|
|
|
|
SLANG_BC_LASSIGN_DLBINARY = 0x99,
|
|
|
|
SLANG_BC_RET_LVARIABLE = 0x9A,
|
|
|
|
SLANG_BC_RET_LITERAL_INT = 0x9B,
|
|
|
|
SLANG_BC_MANY_LVARIABLE = 0x9C,
|
|
|
|
SLANG_BC_MANY_LVARIABLE_DIR = 0x9D,
|
|
|
|
SLANG_BC_LVARIABLE_AGET1 = 0x9E,
|
|
|
|
SLANG_BC_LITERAL_AGET1 = 0x9F,
|
|
|
|
SLANG_BC_LVARIABLE_APUT1 = 0xA0,
|
|
|
|
SLANG_BC_LITERAL_APUT1 = 0xA1,
|
|
|
|
SLANG_BC_UNUSED_0xA2 = 0xA2,
|
|
|
|
SLANG_BC_UNUSED_0xA3 = 0xA3,
|
|
|
|
SLANG_BC_UNUSED_0xA4 = 0xA4,
|
|
|
|
SLANG_BC_UNUSED_0xA5 = 0xA5,
|
|
|
|
SLANG_BC_UNUSED_0xA6 = 0xA6,
|
|
|
|
SLANG_BC_UNUSED_0xA7 = 0xA7,
|
|
|
|
SLANG_BC_UNUSED_0xA8 = 0xA8,
|
|
|
|
SLANG_BC_UNUSED_0xA9 = 0xA9,
|
|
|
|
SLANG_BC_UNUSED_0xAA = 0xAA,
|
|
|
|
SLANG_BC_UNUSED_0xAB = 0xAB,
|
|
|
|
SLANG_BC_UNUSED_0xAC = 0xAC,
|
|
|
|
SLANG_BC_UNUSED_0xAD = 0xAD,
|
|
|
|
SLANG_BC_UNUSED_0xAE = 0xAE,
|
|
|
|
SLANG_BC_UNUSED_0xAF = 0xAF,
|
|
|
|
/* The following do not actually occur in inner_interp. They used
|
|
|
|
* to signify the bytecode has been combined with another.
|
|
|
|
*/
|
|
|
|
SLANG_BC_LVARIABLE_COMBINED = 0xB0,
|
|
|
|
SLANG_BC_GVARIABLE_COMBINED = 0xB1,
|
|
|
|
SLANG_BC_LITERAL_COMBINED = 0xB2,
|
|
|
|
SLANG_BC_CALL_DIRECT_COMB = 0xB3,
|
|
|
|
SLANG_BC_COMBINED = 0xB4,
|
|
|
|
SLANG_BC_UNUSED_0xB5 = 0xB5,
|
|
|
|
SLANG_BC_UNUSED_0xB6 = 0xB6,
|
|
|
|
SLANG_BC_UNUSED_0xB7 = 0xB7,
|
|
|
|
SLANG_BC_UNUSED_0xB8 = 0xB8,
|
|
|
|
SLANG_BC_UNUSED_0xB9 = 0xB9,
|
|
|
|
SLANG_BC_UNUSED_0xBA = 0xBA,
|
|
|
|
SLANG_BC_UNUSED_0xBB = 0xBB,
|
|
|
|
SLANG_BC_UNUSED_0xBC = 0xBC,
|
|
|
|
SLANG_BC_UNUSED_0xBD = 0xBD,
|
|
|
|
SLANG_BC_UNUSED_0xBE = 0xBE,
|
|
|
|
SLANG_BC_UNUSED_0xBF = 0xBF,
|
|
|
|
SLANG_BC_UNUSED_0xC0 = 0xC0,
|
|
|
|
SLANG_BC_UNUSED_0xC1 = 0xC1,
|
|
|
|
SLANG_BC_UNUSED_0xC2 = 0xC2,
|
|
|
|
SLANG_BC_UNUSED_0xC3 = 0xC3,
|
|
|
|
SLANG_BC_UNUSED_0xC4 = 0xC4,
|
|
|
|
SLANG_BC_UNUSED_0xC5 = 0xC5,
|
|
|
|
SLANG_BC_UNUSED_0xC6 = 0xC6,
|
|
|
|
SLANG_BC_UNUSED_0xC7 = 0xC7,
|
|
|
|
SLANG_BC_UNUSED_0xC8 = 0xC8,
|
|
|
|
SLANG_BC_UNUSED_0xC9 = 0xC9,
|
|
|
|
SLANG_BC_UNUSED_0xCA = 0xCA,
|
|
|
|
SLANG_BC_UNUSED_0xCB = 0xCB,
|
|
|
|
SLANG_BC_UNUSED_0xCC = 0xCC,
|
|
|
|
SLANG_BC_UNUSED_0xCD = 0xCD,
|
|
|
|
SLANG_BC_UNUSED_0xCE = 0xCE,
|
|
|
|
SLANG_BC_UNUSED_0xCF = 0xCF,
|
|
|
|
SLANG_BC_UNUSED_0xD0 = 0xD0,
|
|
|
|
SLANG_BC_UNUSED_0xD1 = 0xD1,
|
|
|
|
SLANG_BC_UNUSED_0xD2 = 0xD2,
|
|
|
|
SLANG_BC_UNUSED_0xD3 = 0xD3,
|
|
|
|
SLANG_BC_UNUSED_0xD4 = 0xD4,
|
|
|
|
SLANG_BC_UNUSED_0xD5 = 0xD5,
|
|
|
|
SLANG_BC_UNUSED_0xD6 = 0xD6,
|
|
|
|
SLANG_BC_UNUSED_0xD7 = 0xD7,
|
|
|
|
SLANG_BC_UNUSED_0xD8 = 0xD8,
|
|
|
|
SLANG_BC_UNUSED_0xD9 = 0xD9,
|
|
|
|
SLANG_BC_UNUSED_0xDA = 0xDA,
|
|
|
|
SLANG_BC_UNUSED_0xDB = 0xDB,
|
|
|
|
SLANG_BC_UNUSED_0xDC = 0xDC,
|
|
|
|
SLANG_BC_UNUSED_0xDD = 0xDD,
|
|
|
|
SLANG_BC_UNUSED_0xDE = 0xDE,
|
|
|
|
SLANG_BC_UNUSED_0xDF = 0xDF,
|
|
|
|
SLANG_BC_UNUSED_0xE0 = 0xE0,
|
|
|
|
SLANG_BC_UNUSED_0xE1 = 0xE1,
|
|
|
|
SLANG_BC_UNUSED_0xE2 = 0xE2,
|
|
|
|
SLANG_BC_UNUSED_0xE3 = 0xE3,
|
|
|
|
SLANG_BC_UNUSED_0xE4 = 0xE4,
|
|
|
|
SLANG_BC_UNUSED_0xE5 = 0xE5,
|
|
|
|
SLANG_BC_UNUSED_0xE6 = 0xE6,
|
|
|
|
SLANG_BC_UNUSED_0xE7 = 0xE7,
|
|
|
|
SLANG_BC_UNUSED_0xE8 = 0xE8,
|
|
|
|
SLANG_BC_UNUSED_0xE9 = 0xE9,
|
|
|
|
SLANG_BC_UNUSED_0xEA = 0xEA,
|
|
|
|
SLANG_BC_UNUSED_0xEB = 0xEB,
|
|
|
|
SLANG_BC_UNUSED_0xEC = 0xEC,
|
|
|
|
SLANG_BC_UNUSED_0xED = 0xED,
|
|
|
|
SLANG_BC_UNUSED_0xEE = 0xEE,
|
|
|
|
SLANG_BC_UNUSED_0xEF = 0xEF,
|
|
|
|
SLANG_BC_UNUSED_0xF0 = 0xF0,
|
|
|
|
SLANG_BC_UNUSED_0xF1 = 0xF1,
|
|
|
|
SLANG_BC_UNUSED_0xF2 = 0xF2,
|
|
|
|
SLANG_BC_UNUSED_0xF3 = 0xF3,
|
|
|
|
SLANG_BC_UNUSED_0xF4 = 0xF4,
|
|
|
|
SLANG_BC_UNUSED_0xF5 = 0xF5,
|
|
|
|
SLANG_BC_UNUSED_0xF6 = 0xF6,
|
|
|
|
SLANG_BC_UNUSED_0xF7 = 0xF7,
|
|
|
|
SLANG_BC_UNUSED_0xF8 = 0xF8,
|
|
|
|
SLANG_BC_UNUSED_0xF9 = 0xF9,
|
|
|
|
SLANG_BC_UNUSED_0xFA = 0xFA,
|
|
|
|
SLANG_BC_UNUSED_0xFB = 0xFB,
|
|
|
|
SLANG_BC_UNUSED_0xFC = 0xFC,
|
|
|
|
SLANG_BC_UNUSED_0xFD = 0xFD,
|
|
|
|
SLANG_BC_UNUSED_0xFE = 0xFE,
|
|
|
|
SLANG_BC_UNUSED_0xFF = 0xFF
|
|
|
|
}
|
|
|
|
_pSLang_BC_Type;
|
|
|
|
|
2002-10-07 08:41:03 +04:00
|
|
|
/* Byte-Code Sub Types (_BCST_) */
|
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
/* These are sub_types of SLANG_BC_BLOCK */
|
|
|
|
#define SLANG_BCST_ERROR_BLOCK 0x01
|
|
|
|
#define SLANG_BCST_EXIT_BLOCK 0x02
|
|
|
|
#define SLANG_BCST_USER_BLOCK0 0x03
|
|
|
|
#define SLANG_BCST_USER_BLOCK1 0x04
|
|
|
|
#define SLANG_BCST_USER_BLOCK2 0x05
|
|
|
|
#define SLANG_BCST_USER_BLOCK3 0x06
|
|
|
|
#define SLANG_BCST_USER_BLOCK4 0x07
|
2002-10-07 08:41:03 +04:00
|
|
|
/* The user blocks MUST be in the above order */
|
2005-11-12 22:47:49 +03:00
|
|
|
#define SLANG_BCST_LOOP 0x10
|
|
|
|
#define SLANG_BCST_WHILE 0x11
|
|
|
|
#define SLANG_BCST_FOR 0x12
|
|
|
|
#define SLANG_BCST_FOREVER 0x13
|
|
|
|
#define SLANG_BCST_CFOR 0x14
|
|
|
|
#define SLANG_BCST_DOWHILE 0x15
|
|
|
|
#define SLANG_BCST_FOREACH 0x16
|
|
|
|
#define SLANG_BCST_TRY 0x17
|
|
|
|
|
|
|
|
#define SLANG_BCST_IF 0x20
|
|
|
|
#define SLANG_BCST_IFNOT 0x21
|
|
|
|
#define SLANG_BCST_ELSE 0x22
|
|
|
|
#define SLANG_BCST_ANDELSE 0x23
|
|
|
|
#define SLANG_BCST_ORELSE 0x24
|
|
|
|
#define SLANG_BCST_SWITCH 0x25
|
|
|
|
#define SLANG_BCST_NOTELSE 0x26
|
|
|
|
|
|
|
|
/* assignment (SLANG_BC_SET_*_LVALUE) subtypes. The order MUST correspond
|
2002-10-07 08:41:03 +04:00
|
|
|
* to the assignment token order with the ASSIGN_TOKEN as the first!
|
|
|
|
*/
|
2005-11-12 22:47:49 +03:00
|
|
|
#define SLANG_BCST_ASSIGN 0x01
|
|
|
|
#define SLANG_BCST_PLUSEQS 0x02
|
|
|
|
#define SLANG_BCST_MINUSEQS 0x03
|
|
|
|
#define SLANG_BCST_TIMESEQS 0x04
|
|
|
|
#define SLANG_BCST_DIVEQS 0x05
|
|
|
|
#define SLANG_BCST_BOREQS 0x06
|
|
|
|
#define SLANG_BCST_BANDEQS 0x07
|
|
|
|
#define SLANG_BCST_PLUSPLUS 0x08
|
|
|
|
#define SLANG_BCST_POST_PLUSPLUS 0x09
|
|
|
|
#define SLANG_BCST_MINUSMINUS 0x0A
|
|
|
|
#define SLANG_BCST_POST_MINUSMINUS 0x0B
|
2002-10-07 08:41:03 +04:00
|
|
|
|
|
|
|
/* These use SLANG_PLUS, SLANG_MINUS, SLANG_PLUSPLUS, etc... */
|
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
|
|
|
|
#define LONG_IS_INT (SIZEOF_INT == SIZEOF_LONG)
|
|
|
|
#define LONG_IS_NOT_INT (SIZEOF_INT != SIZEOF_LONG)
|
|
|
|
#define SHORT_IS_INT (SIZEOF_INT == SIZEOF_SHORT)
|
|
|
|
#define SHORT_IS_NOT_INT (SIZEOF_INT != SIZEOF_SHORT)
|
|
|
|
#define LLONG_IS_LONG (SIZEOF_LONG == SIZEOF_LONG_LONG)
|
|
|
|
#define LLONG_IS_NOT_LONG (SIZEOF_LONG != SIZEOF_LONG_LONG)
|
|
|
|
|
|
|
|
/* If long or short are ints, then map the slang types to ints. This is
|
|
|
|
* done because slang has some optimizations for ints.
|
|
|
|
*/
|
|
|
|
#if LONG_IS_INT
|
|
|
|
# define _pSLANG_LONG_TYPE SLANG_INT_TYPE
|
|
|
|
# define _pSLANG_ULONG_TYPE SLANG_UINT_TYPE
|
|
|
|
#else
|
|
|
|
# define _pSLANG_LONG_TYPE SLANG_LONG_TYPE
|
|
|
|
# define _pSLANG_ULONG_TYPE SLANG_ULONG_TYPE
|
|
|
|
#endif
|
|
|
|
#if SHORT_IS_INT
|
|
|
|
# define _pSLANG_SHORT_TYPE SLANG_INT_TYPE
|
|
|
|
# define _pSLANG_USHORT_TYPE SLANG_UINT_TYPE
|
|
|
|
#else
|
|
|
|
# define _pSLANG_SHORT_TYPE SLANG_SHORT_TYPE
|
|
|
|
# define _pSLANG_USHORT_TYPE SLANG_USHORT_TYPE
|
|
|
|
#endif
|
|
|
|
#if LLONG_IS_LONG
|
|
|
|
# define _pSLANG_LLONG_TYPE _pSLANG_LONG_TYPE
|
|
|
|
# define _pSLANG_ULLONG_TYPE _pSLANG_ULONG_TYPE
|
|
|
|
#else
|
|
|
|
# define _pSLANG_LLONG_TYPE SLANG_LLONG_TYPE
|
|
|
|
# define _pSLANG_ULLONG_TYPE SLANG_ULLONG_TYPE
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Map off_t to a slang type */
|
|
|
|
#if defined(HAVE_LONG_LONG) && (SIZEOF_OFF_T == SIZEOF_LONG_LONG) && (SIZEOF_LONG_LONG > SIZEOF_LONG)
|
|
|
|
# define SLANG_C_OFF_T_TYPE _pSLANG_LLONG_TYPE
|
|
|
|
typedef long long _pSLc_off_t_Type;
|
|
|
|
# define SLANG_PUSH_OFF_T SLang_push_long_long
|
|
|
|
#else
|
|
|
|
# if (SIZEOF_OFF_T == SIZEOF_INT)
|
|
|
|
# define SLANG_C_OFF_T_TYPE SLANG_INT_TYPE
|
|
|
|
# define SLANG_PUSH_OFF_T SLang_push_int
|
|
|
|
typedef int _pSLc_off_t_Type;
|
|
|
|
# else
|
|
|
|
# define SLANG_C_OFF_T_TYPE _pSLANG_LONG_TYPE
|
|
|
|
# define SLANG_PUSH_OFF_T SLang_push_long
|
|
|
|
typedef long _pSLc_off_t_Type;
|
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if SIZEOF_INT == 2
|
|
|
|
# define _pSLANG_INT16_TYPE SLANG_INT_TYPE
|
|
|
|
# define _pSLANG_UINT16_TYPE SLANG_UINT_TYPE
|
|
|
|
#else
|
|
|
|
# if SIZEOF_SHORT == 2
|
|
|
|
# define _pSLANG_INT16_TYPE SLANG_SHORT_TYPE
|
|
|
|
# define _pSLANG_UINT16_TYPE SLANG_USHORT_TYPE
|
|
|
|
# else
|
|
|
|
# if SIZEOF_LONG == 2
|
|
|
|
# define _pSLANG_INT16_TYPE SLANG_LONG_TYPE
|
|
|
|
# define _pSLANG_UINT16_TYPE SLANG_ULONG_TYPE
|
|
|
|
# else
|
|
|
|
# define _pSLANG_INT16_TYPE 0
|
|
|
|
# define _pSLANG_UINT16_TYPE 0
|
|
|
|
# endif
|
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if SIZEOF_INT == 4
|
|
|
|
# define _pSLANG_INT32_TYPE SLANG_INT_TYPE
|
|
|
|
# define _pSLANG_UINT32_TYPE SLANG_UINT_TYPE
|
|
|
|
#else
|
|
|
|
# if SIZEOF_SHORT == 4
|
|
|
|
# define _pSLANG_INT32_TYPE SLANG_SHORT_TYPE
|
|
|
|
# define _pSLANG_UINT32_TYPE SLANG_USHORT_TYPE
|
|
|
|
# else
|
|
|
|
# if SIZEOF_LONG == 4
|
|
|
|
# define _pSLANG_INT32_TYPE SLANG_LONG_TYPE
|
|
|
|
# define _pSLANG_UINT32_TYPE SLANG_ULONG_TYPE
|
|
|
|
# else
|
|
|
|
# define _pSLANG_INT32_TYPE 0
|
|
|
|
# define _pSLANG_UINT32_TYPE 0
|
|
|
|
# endif
|
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if SIZEOF_INT == 8
|
|
|
|
# define _pSLANG_INT64_TYPE SLANG_INT_TYPE
|
|
|
|
# define _pSLANG_UINT64_TYPE SLANG_UINT_TYPE
|
|
|
|
#else
|
|
|
|
# if SIZEOF_SHORT == 8
|
|
|
|
# define _pSLANG_INT64_TYPE SLANG_SHORT_TYPE
|
|
|
|
# define _pSLANG_UINT64_TYPE SLANG_USHORT_TYPE
|
|
|
|
# else
|
|
|
|
# if SIZEOF_LONG == 8
|
|
|
|
# define _pSLANG_INT64_TYPE SLANG_LONG_TYPE
|
|
|
|
# define _pSLANG_UINT64_TYPE SLANG_ULONG_TYPE
|
|
|
|
# else
|
|
|
|
# if SIZEOF_LONG_LONG == 8
|
|
|
|
# define _pSLANG_INT64_TYPE SLANG_LLONG_TYPE
|
|
|
|
# define _pSLANG_UINT64_TYPE SLANG_ULLONG_TYPE
|
|
|
|
# else
|
|
|
|
# define _pSLANG_INT64_TYPE 0
|
|
|
|
# define _pSLANG_UINT64_TYPE 0
|
|
|
|
# endif
|
|
|
|
# endif
|
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2002-10-07 08:41:03 +04:00
|
|
|
typedef union
|
|
|
|
{
|
|
|
|
#if SLANG_HAS_FLOAT
|
|
|
|
double double_val;
|
|
|
|
float float_val;
|
2005-11-12 22:47:49 +03:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_LONG_LONG
|
|
|
|
long long llong_val;
|
|
|
|
unsigned long long ullong_val;
|
2002-10-07 08:41:03 +04:00
|
|
|
#endif
|
|
|
|
long long_val;
|
|
|
|
unsigned long ulong_val;
|
|
|
|
VOID_STAR ptr_val;
|
|
|
|
char *s_val;
|
|
|
|
int int_val;
|
|
|
|
unsigned int uint_val;
|
|
|
|
SLang_MMT_Type *ref;
|
|
|
|
SLang_Name_Type *n_val;
|
2005-11-12 22:47:49 +03:00
|
|
|
struct _pSLang_Struct_Type *struct_val;
|
|
|
|
struct _pSLang_Array_Type *array_val;
|
2002-10-07 08:41:03 +04:00
|
|
|
short short_val;
|
|
|
|
unsigned short ushort_val;
|
|
|
|
char char_val;
|
|
|
|
unsigned char uchar_val;
|
2005-11-12 22:47:49 +03:00
|
|
|
SLindex_Type index_val;
|
2002-10-07 08:41:03 +04:00
|
|
|
}
|
2005-11-12 22:47:49 +03:00
|
|
|
_pSL_Object_Union_Type;
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
typedef struct _pSLang_Object_Type
|
2002-10-07 08:41:03 +04:00
|
|
|
{
|
|
|
|
SLtype data_type; /* SLANG_INT_TYPE, ... */
|
2005-11-12 22:47:49 +03:00
|
|
|
_pSL_Object_Union_Type v;
|
2002-10-07 08:41:03 +04:00
|
|
|
}
|
|
|
|
SLang_Object_Type;
|
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
struct _pSLang_MMT_Type
|
2002-10-07 08:41:03 +04:00
|
|
|
{
|
|
|
|
SLtype data_type; /* int, string, etc... */
|
|
|
|
VOID_STAR user_data; /* address of user structure */
|
|
|
|
unsigned int count; /* number of references */
|
|
|
|
};
|
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLang_pop_object_of_type (SLtype, SLang_Object_Type *, int);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
char *name; /* slstring */
|
|
|
|
SLang_Object_Type obj;
|
|
|
|
}
|
2005-11-12 22:47:49 +03:00
|
|
|
_pSLstruct_Field_Type;
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
typedef struct _pSLang_Struct_Type
|
2002-10-07 08:41:03 +04:00
|
|
|
{
|
2005-11-12 22:47:49 +03:00
|
|
|
_pSLstruct_Field_Type *fields;
|
2002-10-07 08:41:03 +04:00
|
|
|
unsigned int nfields; /* number used */
|
|
|
|
unsigned int num_refs;
|
2005-11-12 22:47:49 +03:00
|
|
|
/* user-defined methods */
|
|
|
|
SLang_Name_Type *destroy_method;
|
2002-10-07 08:41:03 +04:00
|
|
|
}
|
2005-11-12 22:47:49 +03:00
|
|
|
_pSLang_Struct_Type;
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern void _pSLstruct_delete_struct (_pSLang_Struct_Type *);
|
|
|
|
extern int _pSLang_push_struct (_pSLang_Struct_Type *);
|
|
|
|
extern int _pSLang_pop_struct (_pSLang_Struct_Type **);
|
|
|
|
extern int _pSLstruct_init (void);
|
|
|
|
/* extern int _pSLstruct_get_field (char *); */
|
|
|
|
extern int _pSLstruct_define_struct (void);
|
|
|
|
extern int _pSLstruct_define_typedef (void);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
struct _pSLang_Ref_Type
|
2002-10-07 08:41:03 +04:00
|
|
|
{
|
|
|
|
int is_global;
|
|
|
|
union
|
|
|
|
{
|
|
|
|
SLang_Name_Type *nt;
|
|
|
|
SLang_Object_Type *local_obj;
|
|
|
|
}
|
|
|
|
v;
|
|
|
|
};
|
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLang_dereference_ref (SLang_Ref_Type *);
|
|
|
|
extern int _pSLang_deref_assign (SLang_Ref_Type *);
|
|
|
|
extern int _pSLang_push_ref (int, VOID_STAR);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSL_increment_frame_pointer (void);
|
|
|
|
extern int _pSL_decrement_frame_pointer (void);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
|
|
|
extern int SLang_pop(SLang_Object_Type *);
|
|
|
|
extern void SLang_free_object (SLang_Object_Type *);
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLanytype_typecast (SLtype, VOID_STAR, unsigned int,
|
2002-10-07 08:41:03 +04:00
|
|
|
SLtype, VOID_STAR);
|
2005-11-12 22:47:49 +03:00
|
|
|
extern void _pSLstring_intrinsic (void);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
#if 0
|
|
|
|
/* NULL not allowed here */
|
|
|
|
extern char *_pSLmalloced_to_slstring (char *, unsigned int);
|
|
|
|
/* But here it is ok */
|
|
|
|
extern int _pSLpush_malloced_string (char *, unsigned int);
|
|
|
|
#endif
|
2002-10-07 08:41:03 +04:00
|
|
|
|
|
|
|
/* These functions are used to create slstrings of a fixed length. Be
|
|
|
|
* very careful how they are used. In particular, if len bytes are allocated,
|
|
|
|
* then the string must be len characters long, no more and no less.
|
|
|
|
*/
|
2005-11-12 22:47:49 +03:00
|
|
|
extern char *_pSLallocate_slstring (unsigned int);
|
|
|
|
extern char *_pSLcreate_via_alloced_slstring (char *, unsigned int);
|
|
|
|
extern void _pSLunallocate_slstring (char *, unsigned int);
|
|
|
|
extern int _pSLpush_alloced_slstring (char *, unsigned int);
|
|
|
|
|
|
|
|
|
|
|
|
extern unsigned int _pSLstring_bytelen (SLstr_Type *);
|
|
|
|
extern void _pSLang_free_slstring (SLstr_Type *); /* slstring required and assumed */
|
|
|
|
extern unsigned long _pSLstring_get_hash (SLstr_Type *s); /* slstring required */
|
|
|
|
|
2002-10-07 08:41:03 +04:00
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
char **buf;
|
|
|
|
unsigned int max_num;
|
|
|
|
unsigned int num;
|
|
|
|
unsigned int delta_num;
|
2005-11-12 22:47:49 +03:00
|
|
|
int is_malloced; /* non-zero if object was malloced */
|
2002-10-07 08:41:03 +04:00
|
|
|
}
|
2005-11-12 22:47:49 +03:00
|
|
|
_pSLString_List_Type;
|
|
|
|
|
|
|
|
/* Note that _pSLstring_list_append makes no copy of the object-- it steals it.
|
|
|
|
* For a copy, use _pSLstring_list_append_copy */
|
|
|
|
extern int _pSLstring_list_append (_pSLString_List_Type *, char *);
|
|
|
|
extern int _pSLstring_list_append_copy (_pSLString_List_Type *, char *);
|
|
|
|
extern int _pSLstring_list_init (_pSLString_List_Type *, unsigned int, unsigned int);
|
|
|
|
extern _pSLString_List_Type *_pSLstring_list_new (unsigned int, unsigned int);
|
|
|
|
extern void _pSLstring_list_delete (_pSLString_List_Type *);
|
|
|
|
extern int _pSLstring_list_push (_pSLString_List_Type *, int);
|
|
|
|
extern SLang_Array_Type *_pSLstrings_to_array (char **strs, unsigned int n);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
|
|
|
/* This function assumes that s is an slstring. */
|
2005-11-12 22:47:49 +03:00
|
|
|
extern char *_pSLstring_dup_slstring (char *);
|
|
|
|
extern int _pSLang_dup_and_push_slstring (char *);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLang_init_import (void);
|
|
|
|
extern int _pSLinit_exceptions (void);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
|
|
|
/* This function checks to see if the referenced object is initialized */
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLang_is_ref_initialized (SLang_Ref_Type *);
|
|
|
|
extern int _pSLcheck_identifier_syntax (char *);
|
|
|
|
extern int _pSLang_uninitialize_ref (SLang_Ref_Type *);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLpush_slang_obj (SLang_Object_Type *);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern char *_pSLexpand_escaped_char(char *, SLwchar_Type *, int *);
|
|
|
|
extern void _pSLexpand_escaped_string (char *, char *, char *);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
|
|
|
/* returns a pointer to an SLstring string-- use SLang_free_slstring */
|
2005-11-12 22:47:49 +03:00
|
|
|
extern char *_pSLstringize_object (SLang_Object_Type *);
|
|
|
|
extern int _pSLdump_objects (char *, SLang_Object_Type *, unsigned int, int);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern SLang_Object_Type *_pSLang_get_run_stack_pointer (void);
|
|
|
|
extern SLang_Object_Type *_pSLang_get_run_stack_base (void);
|
|
|
|
extern int _pSLang_dump_stack (void);
|
|
|
|
extern int _pSLang_peek_at_stack2 (SLtype *);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
struct _pSLang_NameSpace_Type
|
2002-10-07 08:41:03 +04:00
|
|
|
{
|
2005-11-12 22:47:49 +03:00
|
|
|
struct _pSLang_NameSpace_Type *next;
|
2002-10-07 08:41:03 +04:00
|
|
|
char *name; /* this is the load_type name */
|
|
|
|
char *namespace_name; /* this name is assigned by implements */
|
2005-11-12 22:47:49 +03:00
|
|
|
char *private_name;
|
2002-10-07 08:41:03 +04:00
|
|
|
unsigned int table_size;
|
|
|
|
SLang_Name_Type **table;
|
|
|
|
};
|
2005-11-12 22:47:49 +03:00
|
|
|
extern SLang_NameSpace_Type *_pSLns_new_namespace (char *, unsigned int);
|
|
|
|
extern SLang_NameSpace_Type *_pSLns_allocate_namespace (char *, unsigned int);
|
|
|
|
extern void _pSLns_deallocate_namespace (SLang_NameSpace_Type *);
|
|
|
|
extern SLang_NameSpace_Type *_pSLns_find_namespace (char *);
|
|
|
|
extern int _pSLns_set_namespace_name (SLang_NameSpace_Type *, char *);
|
|
|
|
extern SLang_Array_Type *_pSLnspace_apropos (SLang_NameSpace_Type *, char *, unsigned int);
|
|
|
|
extern void _pSLang_use_namespace_intrinsic (char *name);
|
|
|
|
extern char *_pSLang_cur_namespace_intrinsic (void);
|
|
|
|
extern SLang_Array_Type *_pSLang_apropos (char *, char *, unsigned int);
|
|
|
|
extern void _pSLang_implements_intrinsic (char *);
|
|
|
|
extern SLang_Array_Type *_pSLns_list_namespaces (void);
|
|
|
|
extern SLang_Name_Type *_pSLns_locate_hashed_name (SLang_NameSpace_Type *, char *, unsigned long);
|
|
|
|
extern int _pSLns_add_hashed_name (SLang_NameSpace_Type *, SLang_Name_Type *, unsigned long);
|
|
|
|
extern SLang_NameSpace_Type *_pSLns_find_object_namespace (SLang_Name_Type *nt);
|
|
|
|
extern SLang_Name_Type *_pSLns_locate_name (SLang_NameSpace_Type *, char *);
|
|
|
|
extern SLang_NameSpace_Type *_pSLns_get_private_namespace (char *name, char *nsname);
|
|
|
|
extern SLang_NameSpace_Type *_pSLns_create_namespace2 (char *name, char *nsname);
|
|
|
|
|
|
|
|
extern int _pSLang_Trace;
|
|
|
|
extern char *_pSLang_current_function_name (void);
|
|
|
|
|
|
|
|
extern int _pSLang_trace_fun(char *);
|
|
|
|
|
|
|
|
/* This is a bitmapped variable */
|
|
|
|
extern int _pSLang_Compile_Line_Num_Info;
|
|
|
|
#if SLANG_HAS_BOSEOS
|
|
|
|
extern int _pSLang_Compile_BOSEOS;
|
|
|
|
extern int _pSLang_init_boseos (void);
|
|
|
|
extern int _pSLcall_bos_handler (char *, int);
|
|
|
|
extern int _pSLcall_eos_handler (void);
|
|
|
|
extern int _pSLcall_debug_hook (char *file, int linenum);
|
|
|
|
/* extern int _pSLcall_debug_hook (char *file, int linenum, char *funct); */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
extern char *_pSLstring_dup_hashed_string (char *, unsigned long);
|
|
|
|
extern unsigned long _pSLcompute_string_hash (char *);
|
|
|
|
extern char *_pSLstring_make_hashed_string (char *, unsigned int, unsigned long *);
|
|
|
|
extern void _pSLfree_hashed_string (char *, unsigned int, unsigned long);
|
|
|
|
unsigned long _pSLstring_hash (unsigned char *, unsigned char *);
|
|
|
|
extern int _pSLinit_slcomplex (void);
|
|
|
|
|
|
|
|
extern int _pSLang_init_slstrops (void);
|
|
|
|
extern int _pSLstrops_do_sprintf_n (int);
|
|
|
|
extern int _pSLang_sscanf (void);
|
|
|
|
extern double _pSLang_atof (char *);
|
|
|
|
extern int _pSLang_init_bstring (void);
|
|
|
|
extern int _pSLang_init_sltime (void);
|
|
|
|
extern void _pSLpack (void);
|
|
|
|
extern void _pSLunpack (char *, SLang_BString_Type *);
|
|
|
|
extern void _pSLpack_pad_format (char *);
|
|
|
|
extern unsigned int _pSLpack_compute_size (char *);
|
|
|
|
extern int _pSLusleep (unsigned long);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
|
|
|
/* frees upon error. NULL __NOT__ ok. */
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLang_push_slstring (char *);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern SLtype _pSLarith_promote_type (SLtype);
|
|
|
|
extern int _pSLarith_get_precedence (SLtype);
|
|
|
|
extern int _pSLarith_typecast (SLtype, VOID_STAR, unsigned int,
|
2002-10-07 08:41:03 +04:00
|
|
|
SLtype, VOID_STAR);
|
|
|
|
|
|
|
|
extern int SLang_push(SLang_Object_Type *);
|
|
|
|
extern int SLadd_global_variable (char *);
|
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLdo_pop (void);
|
|
|
|
extern unsigned int _pSLsys_getkey (void);
|
|
|
|
extern int _pSLsys_input_pending (int);
|
2002-10-07 08:41:03 +04:00
|
|
|
#ifdef IBMPC_SYSTEM
|
2005-11-12 22:47:49 +03:00
|
|
|
extern unsigned int _pSLpc_convert_scancode (unsigned int, unsigned int, int);
|
|
|
|
#define _pSLTT_KEY_SHIFT 1
|
|
|
|
#define _pSLTT_KEY_CTRL 2
|
|
|
|
#define _pSLTT_KEY_ALT 4
|
2002-10-07 08:41:03 +04:00
|
|
|
#endif
|
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
typedef struct _pSLterminfo_Type SLterminfo_Type;
|
|
|
|
extern SLterminfo_Type *_pSLtt_tigetent (char *);
|
|
|
|
extern char *_pSLtt_tigetstr (SLterminfo_Type *, char *);
|
|
|
|
extern int _pSLtt_tigetnum (SLterminfo_Type *, char *);
|
|
|
|
extern int _pSLtt_tigetflag (SLterminfo_Type *, char *);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
|
|
|
#if SLTT_HAS_NON_BCE_SUPPORT
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLtt_get_bce_color_offset (void);
|
2002-10-07 08:41:03 +04:00
|
|
|
#endif
|
2005-11-12 22:47:49 +03:00
|
|
|
extern void (*_pSLtt_color_changed_hook)(void);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
|
|
|
extern unsigned char SLang_Input_Buffer [SL_MAX_INPUT_BUFFER_LEN];
|
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
typedef struct SL_OOBinary_Type
|
|
|
|
{
|
|
|
|
SLtype data_type; /* partner type for binary op */
|
|
|
|
|
|
|
|
int (*binary_function)_PROTO((int,
|
|
|
|
SLtype, VOID_STAR, unsigned int,
|
|
|
|
SLtype, VOID_STAR, unsigned int,
|
|
|
|
VOID_STAR));
|
|
|
|
|
|
|
|
int (*binary_result) _PROTO((int, SLtype, SLtype, SLtype *));
|
|
|
|
struct SL_OOBinary_Type *next;
|
|
|
|
}
|
|
|
|
SL_OOBinary_Type;
|
|
|
|
|
|
|
|
typedef struct _pSL_Typecast_Type
|
|
|
|
{
|
|
|
|
SLtype data_type; /* to_type */
|
|
|
|
int allow_implicit;
|
|
|
|
|
|
|
|
int (*typecast)_PROTO((SLtype, VOID_STAR, unsigned int,
|
|
|
|
SLtype, VOID_STAR));
|
|
|
|
struct _pSL_Typecast_Type *next;
|
|
|
|
}
|
|
|
|
SL_Typecast_Type;
|
|
|
|
|
|
|
|
struct _pSLang_Class_Type
|
|
|
|
{
|
|
|
|
SLclass_Type cl_class_type; /* vector, scalar, mmt, pointer */
|
|
|
|
|
|
|
|
unsigned int cl_data_type; /* SLANG_INTEGER_TYPE, etc... */
|
|
|
|
char *cl_name; /* slstring type */
|
|
|
|
|
|
|
|
size_t cl_sizeof_type;
|
|
|
|
VOID_STAR cl_transfer_buf; /* cl_sizeof_type bytes*/
|
|
|
|
|
|
|
|
/* Methods */
|
|
|
|
|
|
|
|
/* Most of the method functions are prototyped:
|
|
|
|
* int method (SLtype type, VOID_STAR addr);
|
|
|
|
* Here, @type@ represents the type of object that the method is asked
|
|
|
|
* to deal with. The second parameter @addr@ will contain the ADDRESS of
|
|
|
|
* the object. For example, if type is SLANG_INT_TYPE, then @addr@ will
|
|
|
|
* actually be int *. Similary, if type is SLANG_STRING_TYPE,
|
|
|
|
* then @addr@ will contain the address of the string, i.e., char **.
|
|
|
|
*/
|
|
|
|
|
|
|
|
void (*cl_destroy)_PROTO((SLtype, VOID_STAR));
|
|
|
|
/* Prototype: void destroy(unsigned type, VOID_STAR val)
|
|
|
|
* Called to delete/free the object */
|
|
|
|
|
|
|
|
char *(*cl_string)_PROTO((SLtype, VOID_STAR));
|
|
|
|
/* Prototype: char *to_string (SLtype t, VOID_STAR p);
|
|
|
|
* Here p is a pointer to the object for which a string representation
|
|
|
|
* is to be returned. The returned pointer is to be a MALLOCED string.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Prototype: void push(SLtype type, VOID_STAR v);
|
|
|
|
* Push a copy of the object of type @type@ at address @v@ onto the
|
|
|
|
* stack.
|
|
|
|
*/
|
|
|
|
int (*cl_push)_PROTO((SLtype, VOID_STAR));
|
|
|
|
|
|
|
|
/* Prototype: int pop(SLtype type, VOID_STAR v);
|
|
|
|
* Pops value from stack and assign it to object, whose address is @v@.
|
|
|
|
*/
|
|
|
|
int (*cl_pop)_PROTO((SLtype, VOID_STAR));
|
|
|
|
|
|
|
|
/* mul2, sign, etc... */
|
|
|
|
int (*cl_unary_op_result_type)_PROTO((int, SLtype, SLtype *));
|
|
|
|
int (*cl_unary_op)_PROTO((int, SLtype, VOID_STAR, unsigned int, VOID_STAR));
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
int (*cl_arith_unary_op_result_type)_PROTO((int, SLtype, SLtype *));
|
|
|
|
int (*cl_arith_unary_op)_PROTO((int, SLtype, VOID_STAR, unsigned int, VOID_STAR));
|
|
|
|
#endif
|
|
|
|
int (*cl_app_unary_op_result_type)_PROTO((int, SLtype, SLtype *));
|
|
|
|
int (*cl_app_unary_op)_PROTO((int, SLtype, VOID_STAR, unsigned int, VOID_STAR));
|
|
|
|
|
|
|
|
/* If this function is non-NULL, it will be called for sin, cos, etc... */
|
|
|
|
|
|
|
|
int (*cl_math_op)_PROTO((int, SLtype, VOID_STAR, unsigned int, VOID_STAR));
|
|
|
|
int (*cl_math_op_result_type)_PROTO((int, SLtype, SLtype *));
|
|
|
|
|
|
|
|
SL_OOBinary_Type *cl_binary_ops;
|
|
|
|
SL_Typecast_Type *cl_typecast_funs;
|
|
|
|
|
|
|
|
void (*cl_byte_code_destroy)_PROTO((SLtype, VOID_STAR));
|
|
|
|
void (*cl_user_destroy_fun)_PROTO((SLtype, VOID_STAR));
|
|
|
|
int (*cl_init_array_object)_PROTO((SLtype, VOID_STAR));
|
|
|
|
int (*cl_datatype_deref)_PROTO((SLtype));
|
|
|
|
SLang_Struct_Type *cl_struct_def;
|
|
|
|
int (*cl_dereference) _PROTO((SLtype, VOID_STAR));
|
|
|
|
int (*cl_acopy) (SLtype, VOID_STAR, VOID_STAR);
|
|
|
|
int (*cl_apop) _PROTO((SLtype, VOID_STAR));
|
|
|
|
int (*cl_apush) _PROTO((SLtype, VOID_STAR));
|
|
|
|
int (*cl_push_literal) _PROTO((SLtype, VOID_STAR));
|
|
|
|
void (*cl_adestroy)_PROTO((SLtype, VOID_STAR));
|
|
|
|
int (*cl_push_intrinsic)_PROTO((SLtype, VOID_STAR));
|
|
|
|
int (*cl_void_typecast)_PROTO((SLtype, VOID_STAR, unsigned int, SLtype, VOID_STAR));
|
|
|
|
|
|
|
|
int (*cl_anytype_typecast)_PROTO((SLtype, VOID_STAR, unsigned int, SLtype, VOID_STAR));
|
|
|
|
|
|
|
|
/* Array access functions */
|
|
|
|
int (*cl_aput) (SLtype, unsigned int);
|
|
|
|
int (*cl_aget) (SLtype, unsigned int);
|
|
|
|
int (*cl_anew) (SLtype, unsigned int);
|
|
|
|
|
|
|
|
/* length method */
|
|
|
|
int (*cl_length) (SLtype, VOID_STAR, unsigned int *);
|
|
|
|
|
|
|
|
/* foreach */
|
|
|
|
SLang_Foreach_Context_Type *(*cl_foreach_open) (SLtype, unsigned int);
|
|
|
|
void (*cl_foreach_close) (SLtype, SLang_Foreach_Context_Type *);
|
|
|
|
int (*cl_foreach) (SLtype, SLang_Foreach_Context_Type *);
|
|
|
|
|
|
|
|
/* Structure access: get and put (assign to) fields */
|
|
|
|
int (*cl_sput) (SLtype, char *);
|
|
|
|
int (*cl_sget) (SLtype, char *);
|
|
|
|
|
|
|
|
/* File I/O */
|
|
|
|
int (*cl_fread) (SLtype, FILE *, VOID_STAR, unsigned int, unsigned int *);
|
|
|
|
int (*cl_fwrite) (SLtype, FILE *, VOID_STAR, unsigned int, unsigned int *);
|
|
|
|
int (*cl_fdread) (SLtype, int, VOID_STAR, unsigned int, unsigned int *);
|
|
|
|
int (*cl_fdwrite) (SLtype, int, VOID_STAR, unsigned int, unsigned int *);
|
|
|
|
|
|
|
|
int (*cl_to_bool) (SLtype, int *);
|
|
|
|
|
|
|
|
int (*cl_cmp)(SLtype, VOID_STAR, VOID_STAR, int *);
|
|
|
|
int (*cl_eqs)(SLtype, VOID_STAR, SLtype, VOID_STAR);
|
|
|
|
SL_OOBinary_Type *cl_void_binary_this;
|
|
|
|
SL_OOBinary_Type *cl_this_binary_void;
|
|
|
|
int is_container;
|
|
|
|
};
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLregister_types (void);
|
|
|
|
extern SLang_Class_Type *_pSLclass_get_class (SLtype);
|
|
|
|
extern VOID_STAR _pSLclass_get_ptr_to_value (SLang_Class_Type *, SLang_Object_Type *);
|
|
|
|
extern void _pSLclass_type_mismatch_error (SLtype, SLtype);
|
|
|
|
extern int _pSLclass_init (void);
|
|
|
|
extern int _pSLclass_copy_class (SLtype, SLtype);
|
|
|
|
|
|
|
|
extern int (*_pSLclass_get_typecast (SLtype, SLtype, int))
|
2002-10-07 08:41:03 +04:00
|
|
|
(SLtype, VOID_STAR, unsigned int,
|
|
|
|
SLtype, VOID_STAR);
|
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int (*_pSLclass_get_binary_fun (int, SLang_Class_Type *, SLang_Class_Type *, SLang_Class_Type **, int))
|
2002-10-07 08:41:03 +04:00
|
|
|
(int,
|
|
|
|
SLtype, VOID_STAR, unsigned int,
|
|
|
|
SLtype, VOID_STAR, unsigned int,
|
|
|
|
VOID_STAR);
|
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int (*_pSLclass_get_unary_fun (int, SLang_Class_Type *, SLang_Class_Type **, int))
|
2002-10-07 08:41:03 +04:00
|
|
|
(int, SLtype, VOID_STAR, unsigned int, VOID_STAR);
|
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
#if 0
|
|
|
|
extern int _pSLclass_add_arith_unary_op (SLtype type,
|
|
|
|
int (*f)(int,
|
|
|
|
SLtype, VOID_STAR, unsigned int,
|
|
|
|
VOID_STAR),
|
|
|
|
int (*r)(int, SLtype, SLtype *));
|
|
|
|
#endif
|
|
|
|
|
|
|
|
extern int _pSLclass_get_unary_opcode (char *name);
|
|
|
|
extern int _pSLclass_get_binary_opcode (char *name);
|
|
|
|
extern int _pSLclass_is_same_obj (SLang_Object_Type *a, SLang_Object_Type *b);
|
|
|
|
extern int _pSLclass_obj_eqs (SLang_Object_Type *a, SLang_Object_Type *b);
|
2004-11-01 09:30:43 +03:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLarith_register_types (void);
|
|
|
|
extern SLtype _pSLarith_Arith_Types [];
|
|
|
|
|
|
|
|
extern int _pSLang_ref_is_callable (SLang_Ref_Type *);
|
|
|
|
extern int _pSLang_is_arith_type (SLtype);
|
|
|
|
extern void _pSLang_set_arith_type (SLtype, unsigned char);
|
|
|
|
#if SLANG_OPTIMIZE_FOR_SPEED
|
|
|
|
extern SLclass_Type _pSLang_get_class_type (SLtype);
|
|
|
|
extern void _pSLang_set_class_info (SLtype, SLang_Class_Type *);
|
2004-11-01 09:30:43 +03:00
|
|
|
#endif
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLarith_bin_op (SLang_Object_Type *, SLang_Object_Type *, int);
|
|
|
|
|
|
|
|
extern int _pSLarray_add_bin_op (SLtype);
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
char *name;
|
|
|
|
SLang_Name_Type *next;
|
|
|
|
char name_type;
|
|
|
|
|
|
|
|
int unary_op;
|
|
|
|
}
|
|
|
|
SLang_Arith_Unary_Type;
|
|
|
|
extern int _pSLadd_arith_unary_table (SLang_Arith_Unary_Type *tbl, char *);
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
char *name;
|
|
|
|
SLang_Name_Type *next;
|
|
|
|
char name_type;
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
int binary_op;
|
|
|
|
}
|
|
|
|
SLang_Arith_Binary_Type;
|
|
|
|
extern int _pSLadd_arith_binary_table (SLang_Arith_Binary_Type *tbl, char *);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLang_call_funptr (SLang_Name_Type *);
|
|
|
|
extern void _pSLset_double_format (char *);
|
|
|
|
extern SLang_Name_Type *_pSLlocate_global_name (char *);
|
|
|
|
extern SLang_Name_Type *_pSLlocate_name (char *);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern char *_pSLdefines[];
|
2002-10-07 08:41:03 +04:00
|
|
|
|
|
|
|
#define SL_ERRNO_NOT_IMPLEMENTED 0x7FFF
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLerrno_errno;
|
|
|
|
extern int _pSLerrno_init (void);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLstdio_fdopen (char *, int, char *);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern void _pSLstruct_pop_args (int *);
|
|
|
|
extern void _pSLstruct_push_args (SLang_Array_Type *);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLang_init_sllist (void);
|
|
|
|
extern int _pSLlist_inline_list (void);
|
|
|
|
|
|
|
|
extern int _pSLarray_aput1 (unsigned int);
|
|
|
|
extern int _pSLarray_aput (void);
|
|
|
|
extern int _pSLarray_aget (void);
|
|
|
|
extern int _pSLarray_aget1 (unsigned int);
|
|
|
|
extern int _pSLarray_inline_implicit_array (void);
|
|
|
|
extern int _pSLarray_inline_array (void);
|
|
|
|
extern int _pSLarray_wildcard_array (void);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
|
|
|
extern int
|
2005-11-12 22:47:49 +03:00
|
|
|
_pSLarray_typecast (SLtype, VOID_STAR, unsigned int,
|
2002-10-07 08:41:03 +04:00
|
|
|
SLtype, VOID_STAR, int);
|
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLarray_aput_transfer_elem (SLang_Array_Type *, SLindex_Type *,
|
|
|
|
VOID_STAR, size_t, int);
|
|
|
|
extern int _pSLarray_aget_transfer_elem (SLang_Array_Type *, SLindex_Type *,
|
|
|
|
VOID_STAR, size_t, int);
|
|
|
|
extern void _pSLarray_free_array_elements (SLang_Class_Type *, VOID_STAR, SLuindex_Type);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
|
|
|
extern SLang_Foreach_Context_Type *
|
2005-11-12 22:47:49 +03:00
|
|
|
_pSLarray_cl_foreach_open (SLtype, unsigned int);
|
|
|
|
extern void _pSLarray_cl_foreach_close (SLtype, SLang_Foreach_Context_Type *);
|
|
|
|
extern int _pSLarray_cl_foreach (SLtype, SLang_Foreach_Context_Type *);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLarray_matrix_multiply (void);
|
|
|
|
extern void (*_pSLang_Matrix_Multiply)(void);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLarray_next_index (SLindex_Type *, SLindex_Type *, unsigned int);
|
2004-11-01 09:30:43 +03:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLarray_init_slarray (void);
|
2002-10-07 08:41:03 +04:00
|
|
|
extern SLang_Array_Type *
|
2005-11-12 22:47:49 +03:00
|
|
|
SLang_create_array1 (SLtype, int, VOID_STAR, SLindex_Type *, unsigned int, int);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLassoc_aput (SLtype, unsigned int);
|
|
|
|
extern int _pSLassoc_aget (SLtype, unsigned int);
|
2004-11-01 09:30:43 +03:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLcompile_push_context (SLang_Load_Type *);
|
|
|
|
extern int _pSLcompile_pop_context (void);
|
|
|
|
extern int _pSLang_Auto_Declare_Globals;
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
typedef struct _pSLang_Token_Type
|
2002-10-07 08:41:03 +04:00
|
|
|
{
|
|
|
|
union
|
|
|
|
{
|
|
|
|
long long_val;
|
2005-11-12 22:47:49 +03:00
|
|
|
unsigned long ulong_val;
|
|
|
|
#if HAVE_LONG_LONG
|
|
|
|
long long llong_val;
|
|
|
|
unsigned long long ullong_val;
|
|
|
|
#endif
|
|
|
|
/* Note that it is not wise to put a double field in the union because
|
|
|
|
* when reading a preparsed file, I want to keep the user-specified
|
|
|
|
* form to preserve the precision. Using a union member would mean
|
|
|
|
* converting the double to a string when creating a preparsed file.
|
|
|
|
* We can avoid the issues associated with this by just storing
|
|
|
|
* floating point values as strings.
|
|
|
|
*/
|
|
|
|
char *s_val; /* Used for IDENT_TOKEN, DOUBLE_TOKEN, etc... */
|
|
|
|
|
2002-10-07 08:41:03 +04:00
|
|
|
SLang_BString_Type *b_val;
|
|
|
|
} v;
|
|
|
|
int free_sval_flag;
|
|
|
|
unsigned int num_refs;
|
|
|
|
unsigned long hash;
|
2005-11-12 22:47:49 +03:00
|
|
|
#if SLANG_HAS_DEBUG_CODE
|
2002-10-07 08:41:03 +04:00
|
|
|
int line_number;
|
|
|
|
#endif
|
2005-11-12 22:47:49 +03:00
|
|
|
struct _pSLang_Token_Type *next; /* used for token lists */
|
2002-10-07 08:41:03 +04:00
|
|
|
SLtype type;
|
|
|
|
}
|
2005-11-12 22:47:49 +03:00
|
|
|
_pSLang_Token_Type;
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern void _pSLcompile (_pSLang_Token_Type *);
|
|
|
|
extern void (*_pSLcompile_ptr)(_pSLang_Token_Type *);
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2004-11-01 09:30:43 +03:00
|
|
|
/* slmisc.c */
|
2005-11-12 22:47:49 +03:00
|
|
|
extern char *_pSLskip_whitespace (char *s);
|
2004-11-01 09:30:43 +03:00
|
|
|
|
|
|
|
/* slospath.c */
|
2005-11-12 22:47:49 +03:00
|
|
|
extern char *_pSLpath_find_file (char *); /* slstring returned */
|
2004-11-01 09:30:43 +03:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
/* Read but do not set this variable. */
|
|
|
|
extern volatile int _pSLang_Error;
|
|
|
|
|
|
|
|
extern int _pSLutf8_mode;
|
|
|
|
extern int _pSLinterp_UTF8_Mode; /* non-zero for interpreter */
|
|
|
|
extern int _pSLtt_UTF8_Mode;
|
|
|
|
|
|
|
|
extern SLuchar_Type *_pSLinterp_decode_wchar (SLuchar_Type *u,
|
|
|
|
SLuchar_Type *umax,
|
|
|
|
SLwchar_Type *chp);
|
|
|
|
|
|
|
|
extern SLuchar_Type *_pSLinterp_encode_wchar (SLwchar_Type wch,
|
|
|
|
SLuchar_Type *buf,
|
|
|
|
unsigned int *encoded_lenp);
|
2004-11-01 09:30:43 +03:00
|
|
|
|
2002-10-07 08:41:03 +04:00
|
|
|
/* *** TOKENS *** */
|
|
|
|
|
|
|
|
/* Note that that tokens corresponding to ^J, ^M, and ^Z should not be used.
|
|
|
|
* This is because a file that contains any of these characters will
|
|
|
|
* have an OS dependent interpretation, e.g., ^Z is EOF on MSDOS.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Special tokens */
|
|
|
|
#define ILLEGAL_TOKEN 0x00 /* no token has this value */
|
|
|
|
#define EOF_TOKEN 0x01
|
|
|
|
#define RPN_TOKEN 0x02
|
|
|
|
#define NL_TOKEN 0x03
|
|
|
|
#define NOP_TOKEN 0x05
|
|
|
|
#define FARG_TOKEN 0x06
|
|
|
|
#define TMP_TOKEN 0x07
|
|
|
|
|
|
|
|
#define RESERVED1_TOKEN 0x0A /* \n */
|
|
|
|
#define RESERVED2_TOKEN 0x0D /* \r */
|
|
|
|
|
|
|
|
/* Literal tokens */
|
|
|
|
#define CHAR_TOKEN 0x10
|
|
|
|
#define UCHAR_TOKEN 0x11
|
|
|
|
#define SHORT_TOKEN 0x12
|
|
|
|
#define USHORT_TOKEN 0x13
|
|
|
|
#define INT_TOKEN 0x14
|
|
|
|
#define UINT_TOKEN 0x15
|
|
|
|
#define LONG_TOKEN 0x16
|
|
|
|
#define ULONG_TOKEN 0x17
|
|
|
|
#define IS_INTEGER_TOKEN(x) ((x >= CHAR_TOKEN) && (x <= ULONG_TOKEN))
|
|
|
|
#define FLOAT_TOKEN 0x18
|
|
|
|
#define DOUBLE_TOKEN 0x19
|
|
|
|
#define RESERVED3_TOKEN 0x1A /* ^Z */
|
|
|
|
#define COMPLEX_TOKEN 0x1B
|
|
|
|
#define STRING_TOKEN 0x1C
|
|
|
|
#define BSTRING_TOKEN 0x1D
|
|
|
|
#define _BSTRING_TOKEN 0x1E /* byte-compiled BSTRING */
|
2005-11-12 22:47:49 +03:00
|
|
|
#define STRING_DOLLAR_TOKEN 0x1F
|
2002-10-07 08:41:03 +04:00
|
|
|
|
|
|
|
/* Tokens that can be LVALUES */
|
|
|
|
#define IDENT_TOKEN 0x20
|
|
|
|
#define ARRAY_TOKEN 0x21
|
|
|
|
#define DOT_TOKEN 0x22
|
2005-11-12 22:47:49 +03:00
|
|
|
#define IS_LVALUE_TOKEN (((t) <= DOT_TOKEN) && ((t) >= IDENT_TOKEN))
|
|
|
|
#define DOT_METHOD_CALL_TOKEN 0x23
|
|
|
|
|
|
|
|
#define ESC_STRING_TOKEN 0x24
|
|
|
|
#define ESC_BSTRING_TOKEN 0x25
|
2002-10-07 08:41:03 +04:00
|
|
|
|
|
|
|
/* Flags for struct fields */
|
|
|
|
#define STATIC_TOKEN 0x26
|
|
|
|
#define READONLY_TOKEN 0x27
|
|
|
|
#define PRIVATE_TOKEN 0x28
|
|
|
|
#define PUBLIC_TOKEN 0x29
|
|
|
|
|
|
|
|
/* Punctuation tokens */
|
|
|
|
#define OBRACKET_TOKEN 0x2a
|
|
|
|
#define CBRACKET_TOKEN 0x2b
|
|
|
|
#define OPAREN_TOKEN 0x2c
|
|
|
|
#define CPAREN_TOKEN 0x2d
|
|
|
|
#define OBRACE_TOKEN 0x2e
|
|
|
|
#define CBRACE_TOKEN 0x2f
|
|
|
|
|
|
|
|
#define COMMA_TOKEN 0x31
|
|
|
|
#define SEMICOLON_TOKEN 0x32
|
|
|
|
#define COLON_TOKEN 0x33
|
|
|
|
#define NAMESPACE_TOKEN 0x34
|
|
|
|
|
|
|
|
/* Operators */
|
|
|
|
#define POW_TOKEN 0x38
|
|
|
|
|
|
|
|
/* The order here must match the order in the Binop_Level table in slparse.c */
|
|
|
|
#define FIRST_BINARY_OP 0x39
|
|
|
|
#define ADD_TOKEN 0x39
|
|
|
|
#define SUB_TOKEN 0x3a
|
|
|
|
#define TIMES_TOKEN 0x3b
|
|
|
|
#define DIV_TOKEN 0x3c
|
|
|
|
#define LT_TOKEN 0x3d
|
|
|
|
#define LE_TOKEN 0x3e
|
|
|
|
#define GT_TOKEN 0x3f
|
|
|
|
#define GE_TOKEN 0x40
|
|
|
|
#define EQ_TOKEN 0x41
|
|
|
|
#define NE_TOKEN 0x42
|
|
|
|
#define AND_TOKEN 0x43
|
|
|
|
#define OR_TOKEN 0x44
|
|
|
|
#define MOD_TOKEN 0x45
|
|
|
|
#define BAND_TOKEN 0x46
|
|
|
|
#define SHL_TOKEN 0x47
|
|
|
|
#define SHR_TOKEN 0x48
|
|
|
|
#define BXOR_TOKEN 0x49
|
|
|
|
#define BOR_TOKEN 0x4a
|
|
|
|
#define POUND_TOKEN 0x4b /* matrix multiplication */
|
|
|
|
|
|
|
|
#define LAST_BINARY_OP 0x4b
|
|
|
|
#define IS_BINARY_OP(t) ((t >= FIRST_BINARY_OP) && (t <= LAST_BINARY_OP))
|
|
|
|
|
|
|
|
/* unary tokens -- but not all of them (see grammar) */
|
|
|
|
#define DEREF_TOKEN 0x4d
|
|
|
|
#define NOT_TOKEN 0x4e
|
|
|
|
#define BNOT_TOKEN 0x4f
|
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
#define IS_INTERNAL_FUNC(t) ((t >= 0x50) && (t <= 0x52))
|
2002-10-07 08:41:03 +04:00
|
|
|
#define POP_TOKEN 0x50
|
|
|
|
#define CHS_TOKEN 0x51
|
2005-11-12 22:47:49 +03:00
|
|
|
#define EXCH_TOKEN 0x52
|
|
|
|
|
|
|
|
#define LLONG_TOKEN 0x53
|
|
|
|
#define ULLONG_TOKEN 0x54
|
|
|
|
#define LDOUBLE_TOKEN 0x55
|
2002-10-07 08:41:03 +04:00
|
|
|
|
|
|
|
/* Assignment tokens. Note: these must appear with sequential values.
|
|
|
|
* The order here must match the specific lvalue assignments below.
|
|
|
|
* These tokens are used by rpn routines in slang.c. slparse.c maps them
|
|
|
|
* onto the specific lvalue tokens while parsing infix.
|
2005-11-12 22:47:49 +03:00
|
|
|
* Also the assignment SLANG_BCST_ assumes this order
|
2002-10-07 08:41:03 +04:00
|
|
|
*/
|
|
|
|
#define ASSIGN_TOKEN 0x57
|
|
|
|
#define PLUSEQS_TOKEN 0x58
|
|
|
|
#define MINUSEQS_TOKEN 0x59
|
|
|
|
#define TIMESEQS_TOKEN 0x5A
|
|
|
|
#define DIVEQS_TOKEN 0x5B
|
|
|
|
#define BOREQS_TOKEN 0x5C
|
|
|
|
#define BANDEQS_TOKEN 0x5D
|
|
|
|
#define PLUSPLUS_TOKEN 0x5E
|
|
|
|
#define POST_PLUSPLUS_TOKEN 0x5F
|
|
|
|
#define MINUSMINUS_TOKEN 0x60
|
|
|
|
#define POST_MINUSMINUS_TOKEN 0x61
|
|
|
|
|
|
|
|
/* Directives */
|
|
|
|
#define FIRST_DIRECTIVE_TOKEN 0x62
|
|
|
|
#define IFNOT_TOKEN 0x62
|
|
|
|
#define IF_TOKEN 0x63
|
|
|
|
#define ELSE_TOKEN 0x64
|
|
|
|
#define FOREVER_TOKEN 0x65
|
|
|
|
#define WHILE_TOKEN 0x66
|
|
|
|
#define FOR_TOKEN 0x67
|
|
|
|
#define _FOR_TOKEN 0x68
|
|
|
|
#define LOOP_TOKEN 0x69
|
|
|
|
#define SWITCH_TOKEN 0x6A
|
|
|
|
#define DOWHILE_TOKEN 0x6B
|
|
|
|
#define ANDELSE_TOKEN 0x6C
|
|
|
|
#define ORELSE_TOKEN 0x6D
|
|
|
|
#define ERRBLK_TOKEN 0x6E
|
|
|
|
#define EXITBLK_TOKEN 0x6F
|
|
|
|
/* These must be sequential */
|
|
|
|
#define USRBLK0_TOKEN 0x70
|
|
|
|
#define USRBLK1_TOKEN 0x71
|
|
|
|
#define USRBLK2_TOKEN 0x72
|
|
|
|
#define USRBLK3_TOKEN 0x73
|
|
|
|
#define USRBLK4_TOKEN 0x74
|
|
|
|
|
|
|
|
#define CONT_TOKEN 0x75
|
|
|
|
#define BREAK_TOKEN 0x76
|
|
|
|
#define RETURN_TOKEN 0x77
|
|
|
|
|
|
|
|
#define CASE_TOKEN 0x78
|
|
|
|
#define DEFINE_TOKEN 0x79
|
|
|
|
#define DO_TOKEN 0x7a
|
|
|
|
#define VARIABLE_TOKEN 0x7b
|
|
|
|
#define GVARIABLE_TOKEN 0x7c
|
|
|
|
#define _REF_TOKEN 0x7d
|
|
|
|
#define PUSH_TOKEN 0x7e
|
|
|
|
#define STRUCT_TOKEN 0x7f
|
|
|
|
#define TYPEDEF_TOKEN 0x80
|
|
|
|
#define NOTELSE_TOKEN 0x81
|
|
|
|
#define DEFINE_STATIC_TOKEN 0x82
|
|
|
|
#define FOREACH_TOKEN 0x83
|
|
|
|
#define USING_TOKEN 0x84
|
|
|
|
#define DEFINE_PRIVATE_TOKEN 0x85
|
|
|
|
#define DEFINE_PUBLIC_TOKEN 0x86
|
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
#define TRY_TOKEN 0x87
|
|
|
|
#define CATCH_TOKEN 0x88
|
|
|
|
#define THROW_TOKEN 0x89
|
|
|
|
#define FINALLY_TOKEN 0x8a
|
|
|
|
|
2002-10-07 08:41:03 +04:00
|
|
|
/* Note: the order here must match the order of the generic assignment tokens.
|
|
|
|
* Also, the first token of each group must be the ?_ASSIGN_TOKEN.
|
|
|
|
* slparse.c exploits this order, as well as slang.h.
|
|
|
|
*/
|
|
|
|
#define FIRST_ASSIGN_TOKEN 0x90
|
|
|
|
#define _STRUCT_ASSIGN_TOKEN 0x90
|
|
|
|
#define _STRUCT_PLUSEQS_TOKEN 0x91
|
|
|
|
#define _STRUCT_MINUSEQS_TOKEN 0x92
|
|
|
|
#define _STRUCT_TIMESEQS_TOKEN 0x93
|
|
|
|
#define _STRUCT_DIVEQS_TOKEN 0x94
|
|
|
|
#define _STRUCT_BOREQS_TOKEN 0x95
|
|
|
|
#define _STRUCT_BANDEQS_TOKEN 0x96
|
|
|
|
#define _STRUCT_PLUSPLUS_TOKEN 0x97
|
|
|
|
#define _STRUCT_POST_PLUSPLUS_TOKEN 0x98
|
|
|
|
#define _STRUCT_MINUSMINUS_TOKEN 0x99
|
|
|
|
#define _STRUCT_POST_MINUSMINUS_TOKEN 0x9A
|
|
|
|
|
|
|
|
#define _ARRAY_ASSIGN_TOKEN 0xA0
|
|
|
|
#define _ARRAY_PLUSEQS_TOKEN 0xA1
|
|
|
|
#define _ARRAY_MINUSEQS_TOKEN 0xA2
|
|
|
|
#define _ARRAY_TIMESEQS_TOKEN 0xA3
|
|
|
|
#define _ARRAY_DIVEQS_TOKEN 0xA4
|
|
|
|
#define _ARRAY_BOREQS_TOKEN 0xA5
|
|
|
|
#define _ARRAY_BANDEQS_TOKEN 0xA6
|
|
|
|
#define _ARRAY_PLUSPLUS_TOKEN 0xA7
|
|
|
|
#define _ARRAY_POST_PLUSPLUS_TOKEN 0xA8
|
|
|
|
#define _ARRAY_MINUSMINUS_TOKEN 0xA9
|
|
|
|
#define _ARRAY_POST_MINUSMINUS_TOKEN 0xAA
|
|
|
|
|
|
|
|
#define _SCALAR_ASSIGN_TOKEN 0xB0
|
|
|
|
#define _SCALAR_PLUSEQS_TOKEN 0xB1
|
|
|
|
#define _SCALAR_MINUSEQS_TOKEN 0xB2
|
|
|
|
#define _SCALAR_TIMESEQS_TOKEN 0xB3
|
|
|
|
#define _SCALAR_DIVEQS_TOKEN 0xB4
|
|
|
|
#define _SCALAR_BOREQS_TOKEN 0xB5
|
|
|
|
#define _SCALAR_BANDEQS_TOKEN 0xB6
|
|
|
|
#define _SCALAR_PLUSPLUS_TOKEN 0xB7
|
|
|
|
#define _SCALAR_POST_PLUSPLUS_TOKEN 0xB8
|
|
|
|
#define _SCALAR_MINUSMINUS_TOKEN 0xB9
|
|
|
|
#define _SCALAR_POST_MINUSMINUS_TOKEN 0xBA
|
|
|
|
|
|
|
|
#define _DEREF_ASSIGN_TOKEN 0xC0
|
|
|
|
#define _DEREF_PLUSEQS_TOKEN 0xC1
|
|
|
|
#define _DEREF_MINUSEQS_TOKEN 0xC2
|
|
|
|
#define _DEREF_TIMESEQS_TOKEN 0xC3
|
|
|
|
#define _DEREF_DIVEQS_TOKEN 0xC4
|
|
|
|
#define _DEREF_BOREQS_TOKEN 0xC5
|
|
|
|
#define _DEREF_BANDEQS_TOKEN 0xC6
|
|
|
|
#define _DEREF_PLUSPLUS_TOKEN 0xC7
|
|
|
|
#define _DEREF_POST_PLUSPLUS_TOKEN 0xC8
|
|
|
|
#define _DEREF_MINUSMINUS_TOKEN 0xC9
|
|
|
|
#define _DEREF_POST_MINUSMINUS_TOKEN 0xCA
|
|
|
|
|
|
|
|
#define LAST_ASSIGN_TOKEN 0xCA
|
|
|
|
#define IS_ASSIGN_TOKEN(t) (((t)>=FIRST_ASSIGN_TOKEN)&&((t)<=LAST_ASSIGN_TOKEN))
|
|
|
|
|
|
|
|
#define _INLINE_ARRAY_TOKEN 0xE0
|
|
|
|
#define _INLINE_IMPLICIT_ARRAY_TOKEN 0xE1
|
|
|
|
#define _NULL_TOKEN 0xE2
|
|
|
|
#define _INLINE_WILDCARD_ARRAY_TOKEN 0xE3
|
2005-11-12 22:47:49 +03:00
|
|
|
#define _INLINE_LIST_TOKEN 0xE4
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
#define BOS_TOKEN 0xFA
|
|
|
|
#define EOS_TOKEN 0xFB
|
2002-10-07 08:41:03 +04:00
|
|
|
#define LINE_NUM_TOKEN 0xFC
|
|
|
|
#define ARG_TOKEN 0xFD
|
|
|
|
#define EARG_TOKEN 0xFE
|
|
|
|
#define NO_OP_LITERAL 0xFF
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
/* sltoken.c */
|
|
|
|
/* SLang_eval_object */
|
|
|
|
SLang_Load_Type *llt;
|
2005-11-12 22:47:49 +03:00
|
|
|
SLprep_Type *this_slpp;
|
2002-10-07 08:41:03 +04:00
|
|
|
/* prep_get_char() */
|
|
|
|
char *input_line;
|
|
|
|
char cchar;
|
|
|
|
/* get_token() */
|
|
|
|
int want_nl_token;
|
|
|
|
|
|
|
|
/* slparse.c */
|
2005-11-12 22:47:49 +03:00
|
|
|
_pSLang_Token_Type ctok;
|
2002-10-07 08:41:03 +04:00
|
|
|
int block_depth;
|
|
|
|
int assignment_expression;
|
|
|
|
|
|
|
|
/* slang.c : SLcompile() */
|
2005-11-12 22:47:49 +03:00
|
|
|
_pSLang_Token_Type save_token;
|
|
|
|
_pSLang_Token_Type next_token;
|
|
|
|
void (*slcompile_ptr)(_pSLang_Token_Type *);
|
2002-10-07 08:41:03 +04:00
|
|
|
}
|
2005-11-12 22:47:49 +03:00
|
|
|
_pSLEval_Context;
|
|
|
|
|
|
|
|
extern int _pSLget_token (_pSLang_Token_Type *);
|
|
|
|
extern void _pSLparse_error (int, char *, _pSLang_Token_Type *, int);
|
|
|
|
extern void _pSLparse_start (SLang_Load_Type *);
|
|
|
|
extern int _pSLget_rpn_token (_pSLang_Token_Type *);
|
|
|
|
extern void _pSLcompile_byte_compiled (void);
|
|
|
|
|
|
|
|
extern int (*_pSLprep_eval_hook) (char *);
|
|
|
|
|
|
|
|
extern int _pSLsecure_issetugid (void);
|
|
|
|
extern char *_pSLsecure_getenv (char *);
|
|
|
|
|
|
|
|
/* Error Handling */
|
|
|
|
extern int _pSLang_init_exceptions (void);
|
|
|
|
extern int _pSLerr_init (void);
|
|
|
|
extern void _pSLerr_deinit (void);
|
|
|
|
extern int _pSLerr_suspend_messages (void);
|
|
|
|
extern int _pSLerr_resume_messages (void);
|
|
|
|
extern int _pSLerr_traceback_msg (char *, ...) SLATTRIBUTE_PRINTF(1,2);
|
|
|
|
extern void _pSLerr_dump_msg (char *, ...) SLATTRIBUTE_PRINTF(1,2);
|
|
|
|
extern void _pSLerr_clear_error (void);
|
|
|
|
extern void _pSLerr_print_message_queue (void);
|
|
|
|
|
|
|
|
extern int _pSLerr_set_line_info (char *, int, char *);
|
|
|
|
extern int _pSLang_pop_error_context (void);
|
|
|
|
extern int _pSLang_push_error_context (void);
|
|
|
|
extern void (*_pSLinterpreter_Error_Hook)(int);
|
|
|
|
extern int _pSLerr_init_interp_exceptions (void);
|
|
|
|
extern int _pSLerr_get_last_error (void);
|
|
|
|
extern int _pSLerr_pop_exception (int *);
|
|
|
|
extern void _pSLerr_free_queued_messages (void);
|
|
|
|
extern char *_pSLerr_get_error_from_queue (void);
|
|
|
|
extern int _pSLerr_throw (void);
|
|
|
|
extern int (*_pSLerr_New_Exception_Hook)(char *name, char *desc, int error_code);
|
|
|
|
|
|
|
|
#if SLANG_HAS_DEBUGGER_SUPPORT
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
char **locals;
|
|
|
|
unsigned int nlocals;
|
|
|
|
char *file;
|
|
|
|
unsigned int line;
|
|
|
|
char *function;
|
|
|
|
char *ns;
|
|
|
|
}
|
|
|
|
_pSLang_Frame_Info_Type;
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
extern int _pSLang_get_frame_fun_info (int depth, _pSLang_Frame_Info_Type *info);
|
|
|
|
extern int _pSLang_set_frame_variable (int depth, char *name);
|
|
|
|
extern int _pSLang_get_frame_variable (int depth, char *name);
|
|
|
|
extern void _pSLang_use_frame_namespace (int depth);
|
|
|
|
extern int _pSLang_get_frame_depth (void);
|
|
|
|
#endif
|
2002-10-07 19:48:42 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
#if SLANG_HAS_FLOAT
|
|
|
|
extern int _pSLmath_isnan (double x);
|
2002-10-07 08:41:03 +04:00
|
|
|
#endif
|
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
#if SLANG_HAS_SIGNALS
|
|
|
|
extern void _pSLang_signal_interrupt (void);
|
|
|
|
extern int _pSLsig_block_and_call (int (*)(VOID_STAR), VOID_STAR);
|
|
|
|
extern int _pSLsig_handle_signals (void);
|
|
|
|
extern int _pSLang_check_signals_hook (VOID_STAR);
|
2002-10-07 08:41:03 +04:00
|
|
|
#else
|
2005-11-12 22:47:49 +03:00
|
|
|
#define _pSLsig_block_and_call(f,v) f(v)
|
2002-10-07 08:41:03 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#undef _INLINE_
|
2005-11-12 22:47:49 +03:00
|
|
|
#if defined(__GNUC__) && SLANG_USE_INLINE_CODE
|
2002-10-07 08:41:03 +04:00
|
|
|
# define _INLINE_ __inline__
|
|
|
|
#else
|
|
|
|
# define _INLINE_
|
|
|
|
#endif
|
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
/* This is a macro that permits:
|
|
|
|
*
|
|
|
|
* extern fun (void **addr);
|
|
|
|
* double x;
|
|
|
|
* fun ((void **) &x); <--- warning
|
|
|
|
* fun (VOID_STAR_STAR(&x));
|
|
|
|
*
|
|
|
|
* Otherwise a type-punning warning could result due to strict-aliasing.
|
|
|
|
*/
|
|
|
|
#define VOID_STAR_STAR(addr) (VOID_STAR *)(VOID_STAR)(addr)
|
2002-10-07 08:41:03 +04:00
|
|
|
|
2005-11-12 22:47:49 +03:00
|
|
|
#endif /* PRIVATE_SLANG_H_ */
|