wsasm.h

Go to the documentation of this file.

/* ==================================================================== 
 * The Kannel Software License, Version 1.0 
 * 
 * Copyright (c) 2001-2018 Kannel Group  
 * Copyright (c) 1998-2001 WapIT Ltd.   
 * All rights reserved. 
 * 
 * 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. The end-user documentation included with the redistribution, 
 *    if any, must include the following acknowledgment: 
 *       "This product includes software developed by the 
 *        Kannel Group (http://www.kannel.org/)." 
 *    Alternately, this acknowledgment may appear in the software itself, 
 *    if and wherever such third-party acknowledgments normally appear. 
 * 
 * 4. The names "Kannel" and "Kannel Group" must not be used to 
 *    endorse or promote products derived from this software without 
 *    prior written permission. For written permission, please  
 *    contact org@kannel.org. 
 * 
 * 5. Products derived from this software may not be called "Kannel", 
 *    nor may "Kannel" appear in their name, without prior written 
 *    permission of the Kannel Group. 
 * 
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 KANNEL GROUP OR ITS 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. 
 * ==================================================================== 
 * 
 * This software consists of voluntary contributions made by many 
 * individuals on behalf of the Kannel Group.  For more information on  
 * the Kannel Group, please see <http://www.kannel.org/>. 
 * 
 * Portions of this software are based upon software originally written at  
 * WapIT Ltd., Helsinki, Finland for the Kannel project.  
 */ 

/*
 *
 * wsasm.h
 *
 * Author: Markku Rossi <mtr@iki.fi>
 *
 * Copyright (c) 1999-2000 WAPIT OY LTD.
 *       All rights reserved.
 *
 * Byte-code assembler definitions.
 *
 */

#ifndef WSASM_H
#define WSASM_H

/********************* Opcodes for the ASM instructions *****************/

/* The instruction classes. */

/* Class 1: 1xxPPPPP */

#define WS_ASM_CLASS1P(op)  (((op) & 0x80) == 0x80)
#define WS_ASM_CLASS1_OP(op)    ((op) & 0xe0)
#define WS_ASM_CLASS1_ARG(op)   ((op) & 0x1f)

/* Class 2: 010xPPPP */

#define WS_ASM_CLASS2P(op)  (((op) & 0xe0) == 0x40)
#define WS_ASM_CLASS2_OP(op)    ((op) & 0xf0)
#define WS_ASM_CLASS2_ARG(op)   ((op) & 0x0f)

/* Class 3: 011xxPPP */

#define WS_ASM_CLASS3P(op)  (((op) & 0xe0) == 0x60)
#define WS_ASM_CLASS3_OP(op)    ((op) & 0x78)
#define WS_ASM_CLASS3_ARG(op)   ((op) & 0x07)

/* Class 4: 00xxxxxx */

#define WS_ASM_CLASS4P(op)  (((op) & 0xc0) == 0x00)
#define WS_ASM_CLASS4_OP(op)    (op)

/* Get the opcode of the operand `op'.  The operand `op' can belong to
   any of the classes 1-4. */
#define WS_ASM_OP(op)       \
    (WS_ASM_CLASS1P(op)     \
     ? WS_ASM_CLASS1_OP(op) \
     : (WS_ASM_CLASS2P(op)  \
       ? WS_ASM_CLASS2_OP(op)   \
       : (WS_ASM_CLASS3P(op)    \
         ? WS_ASM_CLASS3_OP(op) \
         : WS_ASM_CLASS4_OP(op))))

/* Get the implicit argument of the operand `op'.  The operand `op'
   can belong to any of the classes 1-4.  For the class 4 operands,
   this returns 0. */
#define WS_ASM_ARG(op)          \
    (WS_ASM_CLASS1P(op)         \
     ? WS_ASM_CLASS1_ARG(op)        \
     : (WS_ASM_CLASS2P(op)      \
       ? WS_ASM_CLASS2_ARG(op)      \
       : (WS_ASM_CLASS3P(op)        \
         ? WS_ASM_CLASS3_ARG(op)    \
         : 0)))

/* Create an operand with implicit argument from the operand `op' and
   argument `arg'. */
#define WS_ASM_GLUE(op, arg)    ((WsByte) (((WsByte) (op)) | ((WsByte) (arg))))


/* The instruction opcodes.             Opcode  Binary   Size   */

#define WS_ASM_JUMP_FW_S        0x80 /* 10000000   1    */
#define WS_ASM_JUMP_FW          0x01 /* 00000001   2    */
#define WS_ASM_JUMP_FW_W        0x02 /* 00000010   3    */

#define WS_ASM_JUMP_BW_S        0xa0 /* 10100000   1    */
#define WS_ASM_JUMP_BW          0x03 /* 00000011   2    */
#define WS_ASM_JUMP_BW_W        0x04 /* 00000100   3    */

#define WS_ASM_TJUMP_FW_S       0xc0 /* 11000000   1    */
#define WS_ASM_TJUMP_FW         0x05 /* 00000101   2    */
#define WS_ASM_TJUMP_FW_W       0x06 /* 00000110   3    */

#define WS_ASM_TJUMP_BW         0x07 /* 00000111   2    */
#define WS_ASM_TJUMP_BW_W       0x08 /* 00001000   3    */

#define WS_ASM_CALL_S           0x60 /* 01100000   1    */
#define WS_ASM_CALL         0x09 /* 00001001   2    */

#define WS_ASM_CALL_LIB_S       0x68 /* 01101000   2    */
#define WS_ASM_CALL_LIB         0x0a /* 00001010   3    */
#define WS_ASM_CALL_LIB_W       0x0b /* 00001011   4    */

#define WS_ASM_CALL_URL         0x0c /* 00001100   4    */
#define WS_ASM_CALL_URL_W       0x0d /* 00001101   6    */

#define WS_ASM_LOAD_VAR_S       0xe0 /* 11100000   1    */
#define WS_ASM_LOAD_VAR         0x0e /* 00001110   2    */

#define WS_ASM_STORE_VAR_S      0x40 /* 01000000   1    */
#define WS_ASM_STORE_VAR        0x0f /* 00001111   2    */

#define WS_ASM_INCR_VAR_S       0x70 /* 01110000   1    */
#define WS_ASM_INCR_VAR         0x10 /* 00010000   2    */

#define WS_ASM_DECR_VAR         0x11 /* 00010001   2    */

#define WS_ASM_LOAD_CONST_S     0x50 /* 01010000   1    */
#define WS_ASM_LOAD_CONST       0x12 /* 00010010   2    */
#define WS_ASM_LOAD_CONST_W     0x13 /* 00010011   3    */

#define WS_ASM_CONST_0          0x14 /* 00010100   1    */
#define WS_ASM_CONST_1          0x15 /* 00010101   1    */
#define WS_ASM_CONST_M1         0x16 /* 00010110   1    */
#define WS_ASM_CONST_ES         0x17 /* 00010111   1    */
#define WS_ASM_CONST_INVALID        0x18 /* 00011000   1    */
#define WS_ASM_CONST_TRUE       0x19 /* 00011001   1    */
#define WS_ASM_CONST_FALSE      0x1a /* 00011010   1    */

#define WS_ASM_INCR         0x1b /* 00011011   1    */
#define WS_ASM_DECR         0x1c /* 00011100   1    */
#define WS_ASM_ADD_ASG          0x1d /* 00011101   2    */
#define WS_ASM_SUB_ASG          0x1e /* 00011110   2    */
#define WS_ASM_UMINUS           0x1f /* 00011111   1    */
#define WS_ASM_ADD          0x20 /* 00100000   1    */
#define WS_ASM_SUB          0x21 /* 00100001   1    */
#define WS_ASM_MUL          0x22 /* 00100010   1    */
#define WS_ASM_DIV          0x23 /* 00100011   1    */
#define WS_ASM_IDIV         0x24 /* 00100100   1    */
#define WS_ASM_REM          0x25 /* 00100101   1    */

#define WS_ASM_B_AND            0x26 /* 00100110   1    */
#define WS_ASM_B_OR             0x27 /* 00100111   1    */
#define WS_ASM_B_XOR            0x28 /* 00101000   1    */
#define WS_ASM_B_NOT            0x29 /* 00101001   1    */
#define WS_ASM_B_LSHIFT         0x2a /* 00101010   1    */
#define WS_ASM_B_RSSHIFT        0x2b /* 00101011   1    */
#define WS_ASM_B_RSZSHIFT       0x2c /* 00101100   1    */

#define WS_ASM_EQ           0x2d /* 00101101   1    */
#define WS_ASM_LE           0x2e /* 00101110   1    */
#define WS_ASM_LT           0x2f /* 00101111   1    */
#define WS_ASM_GE           0x30 /* 00110000   1    */
#define WS_ASM_GT           0x31 /* 00110001   1    */
#define WS_ASM_NE           0x32 /* 00110010   1    */

#define WS_ASM_NOT          0x33 /* 00110011   1    */
#define WS_ASM_SCAND            0x34 /* 00110100   1    */
#define WS_ASM_SCOR             0x35 /* 00110101   1    */
#define WS_ASM_TOBOOL           0x36 /* 00110110   1    */

#define WS_ASM_POP          0x37 /* 00110111   1    */

#define WS_ASM_TYPEOF           0x38 /* 00111000   1    */
#define WS_ASM_ISVALID          0x39 /* 00111001   1    */

#define WS_ASM_RETURN           0x3a /* 00111010   1    */
#define WS_ASM_RETURN_ES        0x3b /* 00111011   1    */

#define WS_ASM_DEBUG            0x3c /* 00111100   1    */

/********************* Pseudo opcodes for assembler *********************/

/* These are pseudo opcodes grouping together several real byte-code
   opcodes.  These are used in the symbolic assembler. */

#define WS_ASM_P_LABEL      0x0100
#define WS_ASM_P_JUMP       0x0200
#define WS_ASM_P_TJUMP      0x0300
#define WS_ASM_P_CALL       0x0400
#define WS_ASM_P_CALL_LIB   0x0500
#define WS_ASM_P_CALL_URL   0x0600
#define WS_ASM_P_LOAD_VAR   0x0700
#define WS_ASM_P_STORE_VAR  0x0800
#define WS_ASM_P_INCR_VAR   0x0900
#define WS_ASM_P_LOAD_CONST 0x0a00

/* Check whether the instruction `ins' is a pseudo-branch
   instruction. */
#define WS_ASM_P_BRANCH(ins) \
    ((ins)->type == WS_ASM_P_JUMP || (ins)->type == WS_ASM_P_TJUMP)

/********************* Symbolic assembler instructions ******************/

#define ws_label_idx        u.ivalues.i1
#define ws_label_refcount   u.ivalues.i2
#define ws_findex       u.ivalues.i1
#define ws_lindex       u.ivalues.i2
#define ws_args         u.ivalues.i3
#define ws_vindex       u.ivalues.i1
#define ws_cindex       u.ivalues.i1
#define ws_label        u.branch.label
#define ws_offset       u.branch.offset

struct WsAsmInsRec
{
    struct WsAsmInsRec *next;
    struct WsAsmInsRec *prev;
    WsUInt16 type;

    /* The source stream line number. */
    WsUInt32 line;

    /* The operands offset in the linearized byte-code stream. */
    WsUInt32 offset;

    union
    {
        /* The target label for branch instructions. */
        struct
        {
            struct WsAsmInsRec *label;

            /* The offset argument of the branch operand.  This is the
               adjustment that must be performed for the pc after this
               instruction. */
            WsUInt32 offset;
        }
        branch;

        struct
        {
            WsUInt32 i1;
            WsUInt16 i2;
            WsUInt16 i3;
        }
        ivalues;
    } u;
};

typedef struct WsAsmInsRec WsAsmIns;


/* Link the instruction `ins' to the end of the symbolic assembler
   chain, currently being constructed in `compiler'. */
void ws_asm_link(WsCompilerPtr compiler, WsAsmIns *ins);

/* Print the current assembler instructions of the compiler
   `compiler'. */
void ws_asm_print(WsCompilerPtr compiler);

/* Disassemble the byte-code `code', `len' to the standard output. */
void ws_asm_dasm(WsCompilerPtr compiler, const unsigned char *code,
                 size_t len);

/* Linearize the assembler, currently being constructed in `compiler',
   into `compiler->byte_code'. */
void ws_asm_linearize(WsCompilerPtr compiler);

/* Constructors for assembler instructions. */

/* Create a label instruction. */
WsAsmIns *ws_asm_label(WsCompilerPtr compiler, WsUInt32 line);

/* Create a branch instruction `ins' to label `label'. */
WsAsmIns *ws_asm_branch(WsCompilerPtr compiler, WsUInt32 line, WsUInt16 ins,
                        WsAsmIns *label);

/* Create a local call instruction to function `findex'. */
WsAsmIns *ws_asm_call(WsCompilerPtr compiler, WsUInt32 line, WsUInt8 findex);

/* Create a library call instruction to function `findex' from the
   libary `lindex'. */
WsAsmIns *ws_asm_call_lib(WsCompilerPtr compiler, WsUInt32 line,
                          WsUInt8 findex, WsUInt16 lindex);

/* Create an URL call instruction for function `findex' from the URL
   `urlindex' with `args' arguments.  The arguments `urlindex' and
   `findex' pont to the constant pool. */
WsAsmIns *ws_asm_call_url(WsCompilerPtr compiler, WsUInt32 line,
                          WsUInt16 findex, WsUInt16 urlindex, WsUInt8 args);

/* Create a variable modification instruction `ins' for the variable
   `vindex'. */
WsAsmIns *ws_asm_variable(WsCompilerPtr compiler, WsUInt32 line, WsUInt16 ins,
                          WsUInt8 vindex);

/* Create a constant loading instruction for the constant `cindex'. */
WsAsmIns *ws_asm_load_const(WsCompilerPtr compiler, WsUInt32 line,
                            WsUInt16 cindex);

/* Create an instruction `ins'. */
WsAsmIns *ws_asm_ins(WsCompilerPtr compiler, WsUInt32 line, WsUInt8 opcode);

#endif /* not WSASM_H */