#ifndef _RPN32_H_INCLUDED


#ifdef __cplusplus
extern "C" {
#endif



/*============================================================================*\
                                    API
\*============================================================================*/


/*----------------------------------------------------------------------------*\
                                    TYPY
\*----------------------------------------------------------------------------*/


// "Handle"
//
typedef struct rpn32hndls               *rpn32hndl_t;


// Typ vypoctenych hodnot
//
#define _RPN32GENERIC_T                 int     // genericky typ
//
typedef signed   _RPN32GENERIC_T        rpn32value_t;
typedef unsigned _RPN32GENERIC_T        rpn32uvalu_t;



/*----------------------------------------------------------------------------*\
                            NAVRATOVE HODNOTY FUNKCI
\*----------------------------------------------------------------------------*/


// Seznam (kompletni sortiment) CHYBOVYCH navratovych hodnot
//
#define  RPN32_RTNVAL_ERROR_LIST(p)                                         \
/* - pouze pri provadeni programu                                       */  \
                p##_INVALID,    /*  chybna hodnota pro operaci          */  \
                p##_DIVBY0,     /*  deleni nulou                        */  \
                p##_RTNOVF,     /*  neni kam ukladat navrat.adresy      */  \
                p##_REGOVF,     /*  index registru mimo rozsah          */  \
/* - pri sestavovani nebo provadeni programu                            */  \
                p##_ILLEGAL,    /*  neznama instrukce                   */  \
                p##_LBLNEX,     /*  neexistujici navesti                */  \
                p##_LBLOVF,     /*  navesti mimo rozsah                 */  \
/* pouze pri sestavovani binarniho tvaru programu                       */  \
                p##_MEMREQ,     /*  nerealny pozadavek na pamet (>2GB)  */  \
                p##_MEMORY,     /*  nebyl uspokojen pozadavek na pamet  */  \
                p##_LBLDUP,     /*  duplikovane navesti                 */  \
                p##_OPERAND,    /*  chybny operand                      */  \
                p##_NUMBER,     /*  chybny pocet operandu               */  \
                p##_IMOP        /*  chybny "immediate operand"          */


// Pomocny seznam pro urceni poctu polozek seznamu CHYBOVYCH navratovych hodnot.
// Posledni polozka seznamu bude VZDY mit hodnotu (-1), ostatni (-2), (-3), ...
//
enum    {RPN32_RTNVAL_ERROR_LIST(_RPN32_RTNVAL_ERROR_COUNT),
        _RPN32_RTNVAL_ERROR_COUNT_BASE};


// Navratove hodnoty
//
enum   {_RPN32_RTNVAL_ERROR_START = -(_RPN32_RTNVAL_ERROR_COUNT_BASE + 1),
// CHYBOVE
         RPN32_RTNVAL_ERROR_LIST(RPN32_RTNVAL),
// BEZCHYBNE
         RPN32_RTNVAL_DONE,             // vse vyrizeno k dennimu poradku
         RPN32_RTNVAL_STOP,             // "R/S" (run/stop)
         RPN32_RTNVAL_USER};
/*
  Hodnota "RPN32_RTNVAL_USER" neni v ramci "RPN32" pouzita vseobecne.
  Je vhodna pro urceni zacatku posloupnosti vlastnich/uzivatelskych hodnot
  (viz funkce "rpn32_now()").
 */


// Operace s navratovymi hodnotami
//
#define  RPN32_RTNVAL_ERROR_INDEX(e)    ((e) - _RPN32_RTNVAL_ERROR_START - 1)
//
#define  RPN32_RTNVAL_IS_ERROR(v)       ((v) <  RPN32_RTNVAL_DONE)
#define  RPN32_RTNVAL_IS_RTNVAL(v)      ((v) <  RPN32_RTNVAL_USER)



/*----------------------------------------------------------------------------*\
                INICIALIZACE - ZPRACOVANI TEXTOVE PODOBY PROGRAMU
\*----------------------------------------------------------------------------*/


// Duvod volani "callback" funkce (hodnoty argumentu "__type")
//
enum   {RPN32_INIT_CB_TYPE_LINE,        // zadost o programovou radku
        RPN32_INIT_CB_TYPE_MEMORY,      // zadost o prideleni pameti
        RPN32_INIT_CB_TYPE_UNKNOWN};    // neznama radka


// Argumenty "callback" funkce
//
typedef union
{
    char const      *linep;             // "RPN32_INIT_CB_TYPE_LINE/UNKNOWN"
    struct
    {
        void        *memp;
        unsigned    size;
    }               memoryv;            // "RPN32_INIT_CB_TYPE_MEMORY"
} rpn32initarg_t;


// "Callback" funkce
//
typedef int         (*rpn32initcb_t)(int             __type,
                                     rpn32initarg_t *__iap,
                                     void           *__userdata);
/*
vstup:
  __type:           "RPN32_INIT_CB_TYPE_*".
  __iap->size:      Doporucene mnozstvi pridelene pameti, muze byt i vice.
  __iap->linep:     Chybna programova radka.
  __userdata:       Libovolna/uzivatelska hodnota.

vystup:
  __iap->linep:     Programova radka pro zpracovani.
  __iap->memp:      Pointer na pridelenou pamet.
  __iap->size:      Skutecne mnozstvi pridelene pameti.

vraci:              "RPN32_RTNVAL_DONE/STOP"
 */


// Vykonna funkce
//
extern int          rpn32_init(rpn32hndl_t  *__hndpp,
                               rpn32initcb_t __fncp,
                               void         *__userdata);
/*
vstup:
  __hndpp:          Pointer na "handle".
  __fncp:           Pointer na "callback" funkci.
  __userdata:       Libovolna/uzivatelska hodnota pro "callback" funkci.

vystup:
 *__hndpp:          "Handle".

vraci:              "RPN32_RTNVAL_*"
 */



/*----------------------------------------------------------------------------*\
                                    VYPISY
\*----------------------------------------------------------------------------*/


// "Callback" funkce
//
typedef int         (*rpn32viewcb_t)(char const *__linep,
                                     void       *__userdata);
/*
vstup:
  __linep:          Radka textu pro vypis.
  __userdata:       Libovolna/uzivatelska hodnota.

vraci:              "RPN32_RTNVAL_DONE/STOP"
 */


// "Pohled" na aktualni stav (aresa, programova radka, obsahy registru, ...)
//
extern int          rpn32_view(rpn32hndl_t   __hndp,
                               char const   *__modep,
                               rpn32viewcb_t __fncp,
                               void         *__userdata);
/*
vstup:
  __hndp:           "Handle".
  __modep:          Retezec sestaveny ze sortimentu "RPN32_VIEW_MODE_*".
                    Znaky urcuji poradi, posledni je vzdy instrukce.
  __fncp:           Pointer na "callback" funkci.
  __userdata:       Libovolna/uzivatelska hodnota pro "callback" funkci.

vraci:              "RPN32_RTNVAL_*"
 */


// Vypis celeho programu
//
extern int          rpn32_list(rpn32hndl_t   __hndp,
                               char const   *__modep,
                               rpn32viewcb_t __fncp,
                               void         *__userdata);
/*
  Viz "rpn32_view()".
 */


// Vypis pouzite pameti
//
extern int          rpn32_mem(rpn32hndl_t   __hndp,
                              rpn32viewcb_t __fncp,
                              void         *__userdata);
/*
vstup:
  __hndp:           "Handle".
  __fncp:           Pointer na "callback" funkci.
  __userdata:       Libovolna/uzivatelska hodnota pro "callback" funkci.

vraci:              "RPN32_RTNVAL_*"
 */


// Rizeni vypisu (znaky, z nichz je sestaven retezec/argument "__modep")
//
// - kdykoliv, i pri "rpn32_list()"
#define  RPN32_VIEW_MODE_CHR_ADDRESS    'a'
#define  RPN32_VIEW_MODE_STR_ADDRESS    "a"
#define  RPN32_VIEW_MODE_CHR_CODE       'c'
#define  RPN32_VIEW_MODE_STR_CODE       "c"
#define  RPN32_VIEW_MODE_CHR_LINE       'i'     // opacny vyznam, bez vypisu
#define  RPN32_VIEW_MODE_STR_LINE       "i"
#define  RPN32_VIEW_MODE_CHR_COMPAT     'p'     // kompatibilita vypisu...
#define  RPN32_VIEW_MODE_STR_COMPAT     "p"     // ...s "RPNPROC"
#define  RPN32_VIEW_MODE_CHR_SEPARATOR  ','     // bez vyznamu, pouze oddelovac
#define  RPN32_VIEW_MODE_STR_SEPARATOR  ","
#define  RPN32_VIEW_MODE_CHR_ESCAPE     '\\'    // "Escape prefix"
#define  RPN32_VIEW_MODE_STR_ESCAPE     "\\"
// - obvykle pri "rpn32_view()"
#define  RPN32_VIEW_MODE_CHR_SGN        's'
#define  RPN32_VIEW_MODE_STR_SGN        "s"
#define  RPN32_VIEW_MODE_CHR_UNS        'u'
#define  RPN32_VIEW_MODE_STR_UNS        "u"
#define  RPN32_VIEW_MODE_CHR_DEC        'd'
#define  RPN32_VIEW_MODE_STR_DEC        "d"
#define  RPN32_VIEW_MODE_CHR_OCT        'o'
#define  RPN32_VIEW_MODE_STR_OCT        "o"
#define  RPN32_VIEW_MODE_CHR_HEX        'h'
#define  RPN32_VIEW_MODE_STR_HEX        "h"
#define  RPN32_VIEW_MODE_CHR_INDIRECT   RPN32_TEXT_CODE_CHR_INDIRECT
#define  RPN32_VIEW_MODE_STR_INDIRECT   RPN32_TEXT_CODE_STR_INDIRECT
#define  RPN32_VIEW_MODE_CHR_LOCREG     RPN32_TEXT_CODE_CHR_LOCREG
#define  RPN32_VIEW_MODE_STR_LOCREG     RPN32_TEXT_CODE_STR_LOCREG
#define  RPN32_VIEW_MODE_CHR_STACK      'k'
#define  RPN32_VIEW_MODE_STR_STACK      "k"
#define  RPN32_VIEW_MODE_CHR_FLAGS      'f'
#define  RPN32_VIEW_MODE_STR_FLAGS      RPN32_TEXT_CODE_STR_REG_FLAGS
#define  RPN32_VIEW_MODE_CHR_RTN        'r'
#define  RPN32_VIEW_MODE_STR_RTN        "r"
#define  RPN32_VIEW_MODE_CHR_LOCNUM     'g'
#define  RPN32_VIEW_MODE_STR_LOCNUM     "g"
#define  RPN32_VIEW_MODE_CHR_USUAL      '='
#define  RPN32_VIEW_MODE_STR_USUAL      "="
#define  RPN32_VIEW_MODE_COMB_USUAL     RPN32_VIEW_MODE_STR_STACK           \
                                        RPN32_VIEW_MODE_STR_REG_LASTX       \
                                        RPN32_VIEW_MODE_STR_ADDRESS
// - registry
#define  RPN32_VIEW_MODE_STR_REG_X      RPN32_TEXT_CODE_STR_REG_X
#define  RPN32_VIEW_MODE_STR_REG_Y      RPN32_TEXT_CODE_STR_REG_Y
#define  RPN32_VIEW_MODE_STR_REG_Z      RPN32_TEXT_CODE_STR_REG_Z
#define  RPN32_VIEW_MODE_STR_REG_T      RPN32_TEXT_CODE_STR_REG_T
#define  RPN32_VIEW_MODE_STR_REG_LASTX  RPN32_TEXT_CODE_STR_REG_LASTX
/*
  Pozn.: Textovy tvar instrukce (viz "_LINE") je vzdy na konci radky vypisu.
 */


// Identifikatory (prefixy) v textovem vystupu funkce "rpn32_mem()"
//
// - rozsah cisel pametovych registru,
// - rozsah cisel navesti,
// - velikost zasobniku navratovych adres,
// - celkovy pocet lokalnich registru.
//
#define _RPN32_MEM_TXTID_STR_REG        "REG"
#define _RPN32_MEM_TXTID_STR_LBL        RPN32_TEXT_CODE_STR_LBL
#define _RPN32_MEM_TXTID_STR_RTN        RPN32_TEXT_CODE_STR_RTN
#define _RPN32_MEM_TXTID_STR_LOC        "LOC"
#define  RPN32_MEM_TXTID_STR(k)        _RPN32_MEM_TXTID_STR_##k ": "



/*----------------------------------------------------------------------------*\
                            OPERACE S RPN-STACKEM
\*----------------------------------------------------------------------------*/


// Vstup hodnoty na RPN-stack
//
extern rpn32value_t rpn32_enter(rpn32hndl_t  __hndp,
                                rpn32value_t __value);
/*
vstup:
  __hndp:           "Handle".
  __value:          Vkladana hodnota.

vraci:              Vkladanou hodnotu.
 */


// Vstup hodnoty v textovem tvaru na RPN-stack
//
extern int          rpn32_tenter(rpn32hndl_t __hndp,
                                 char const *__valp);
/*
vstup:
  __hndp:           "Handle".
  __valp:           Vkladana hodnota v textovem tvaru.

vraci:              "RPN32_RTNVAL_*".
 */


// Vycteni X-registru RPN-stacku a "Roll down"
//
extern rpn32value_t rpn32_rdn(rpn32hndl_t __hndp);
/*
vstup:
  __hndp:           "Handle".

vraci:              Hodnotu z X-registru pred "Roll down".
 */


// Pouhe vycteni X-registru
//
extern rpn32value_t rpn32_regx(rpn32hndl_t __hndp);
/*
vstup:
  __hndp:           "Handle".

vraci:              Hodnotu z X-registru.
 */



/*----------------------------------------------------------------------------*\
                            PROVADENI PROGRAMU
\*----------------------------------------------------------------------------*/


// Duvod volani "callback" funkce (hodnoty argumentu "__type")
//
enum   {RPN32_RUN_CB_TYPE_TRACE,        // Pred provedenim kazde instrukce.
        RPN32_RUN_CB_TYPE_PSE};         // Instrukce "PSE".


// "Callback" funkce
//
typedef int         (*rpn32runcb_t)(int   __type,
                                    void *__userdata);
/*
vstup:
  __type:           "RPN32_RUN_CB_TYPE_*".
  __userdata:       Libovolna/uzivatelska hodnota.

vraci:              "RPN32_RTNVAL_DONE/STOP"
 */


// Spusteni/pokracovani programu
//
extern int          rpn32_run(rpn32hndl_t  __hndp,
                              int          __type,
                              rpn32runcb_t __fncp,
                              void        *__userdata);
/*
vstup:
  __hndp:           "Handle".
  __type:           "RPN32_RUN_CB_TYPE_*".
  __fncp:           Pointer na "callback" funkci nebo NULL.
  __userdata:       Libovolna/uzivatelska hodnota pro "callback" funkci.

vraci:              "RPN32_RTNVAL_*"
 */


// Skok na adresu danou navestim
//
extern int          rpn32_gto(rpn32hndl_t __hndp,
                              int         __lblno);
/*
vstup:
  __hndp:           "Handle".
  __lblno:          Cislo navesti od ktereho je program spusten.
                    Pri zadani < 0 je pozice v programu nastavena na zacatek
                    a "zapomenuty" vsecny navratovych hodnoty.

vraci:              "RPN32_RTNVAL_DONE/LBLOVF".
 */



/*----------------------------------------------------------------------------*\
                                LADICI FUNKCE
\*----------------------------------------------------------------------------*/


// Zpracovani jedne programove radky - interaktivni mod
//
enum   {RPN32_NOW_RTNVAL_YES = RPN32_RTNVAL_USER,
        RPN32_NOW_RTNVAL_NO};
//
extern int          rpn32_now(rpn32hndl_t __hndp,
                              char const *__linep);
/*
vstup:
  __hndp:           "Handle".
  __linep:          Programova radka pro zpracovani.

vraci:              "RPN32_NOW_RTNVAL_*", "RPN32_RTNVAL_*".
 */



/*============================================================================*\
                            TEXTOVE PODOBY INSTRUKCI
\*============================================================================*/


/*----------------------------------------------------------------------------*\
                                TEXTOVE RETEZCE
\*----------------------------------------------------------------------------*/


// Maximalni delka textoveho retezce instrukce
//
#define  RPN32_TEXT_CODE_STR_MAXLEN     6


// Manipulace s RPN stackem
//
#define  RPN32_TEXT_CODE_STR_ENTER      "ENTER" // lift up, LIFT_FLAG=0
#define  RPN32_TEXT_CODE_STR_SWAP       "x<>y"  // exchange X<->Y
#define  RPN32_TEXT_CODE_STR_RDN        "Rdn"   // roll down
#define  RPN32_TEXT_CODE_STR_RUP        "Rup"   // roll up
#define  RPN32_TEXT_CODE_STR_CLX        "CLx"   // 0->X, LIFT_FLAG=0
#define  RPN32_TEXT_CODE_STR_CLST       "CLST"  // 0->[X,Y,Z,T], LIFT_FLAG=0
#define  RPN32_TEXT_CODE_STR_LASTX      "LASTx" // LASTx->X


// Operace s X-, Y- a Z-registrem RPN stacku
//
#define  RPN32_TEXT_CODE_STR_LCN        "LCN"   // compose LCN


// Operace s X- a Y-registrem RPN stacku
//
#define  RPN32_TEXT_CODE_STR_ADD        "+"     // Y+X
#define  RPN32_TEXT_CODE_STR_SUB        "-"     // Y-X
#define  RPN32_TEXT_CODE_STR_MUL        "*"     // Y*X
#define  RPN32_TEXT_CODE_STR_DIV        "/"     // Y/X
#define  RPN32_TEXT_CODE_STR_RMD        "RMD"   // Y%X
#define  RPN32_TEXT_CODE_STR_OR         "OR"    // Y|X
#define  RPN32_TEXT_CODE_STR_XOR        "XOR"   // Y^X
#define  RPN32_TEXT_CODE_STR_AND        "AND"   // Y&X
#define  RPN32_TEXT_CODE_STR_SLN        "SLn"   // Y<<X
#define  RPN32_TEXT_CODE_STR_SRN        "SRn"   // Y>>X
#define  RPN32_TEXT_CODE_STR_RLN        "RLn"   // Y rotate_left X
#define  RPN32_TEXT_CODE_STR_RRN        "RRn"   // Y rotate_right X
#define  RPN32_TEXT_CODE_STR_SBIT       "SB"    // Y|1<<X
#define  RPN32_TEXT_CODE_STR_CBIT       "CB"    // Y&~(1<<X)
#define  RPN32_TEXT_CODE_STR_XBIT       "XB"    // Y^1<<X
#define  RPN32_TEXT_CODE_STR_VBIT       "B?"    // (Y&1<<X)!=0


// Operace s X-registrem RPN stacku
//
#define  RPN32_TEXT_CODE_STR_CHS        "CHS"   // -X
#define  RPN32_TEXT_CODE_STR_NOT        "NOT"   // ~X
#define  RPN32_TEXT_CODE_STR_ABS        "ABS"   // abs(X)
#define  RPN32_TEXT_CODE_STR_SIGNUM     "SIGN"  // signum(X)
#define  RPN32_TEXT_CODE_STR_SL1        "SL"    // X<<1
#define  RPN32_TEXT_CODE_STR_SR1        "SR"    // X>>1
#define  RPN32_TEXT_CODE_STR_RL1        "RL"    // X rotate_left 1
#define  RPN32_TEXT_CODE_STR_RR1        "RR"    // X rotate_right 1
#define  RPN32_TEXT_CODE_STR_MASKL      "MASKL" // (1<<X)-1<<wide-X
#define  RPN32_TEXT_CODE_STR_MASKR      "MASKR" // (1<<X)-1
#define  RPN32_TEXT_CODE_STR_CONVB      "CONVB" // byte...
#define  RPN32_TEXT_CODE_STR_CONVW      "CONVW" // ...word extension
#define  RPN32_TEXT_CODE_STR_LJ         "LJ"    // left justify
#define  RPN32_TEXT_CODE_STR_COUNT      "COUNT" // counter of LCN
#define  RPN32_TEXT_CODE_STR_NBIT       "NB"    // number_of_bits(X)
#define  RPN32_TEXT_CODE_STR_WSIZE      "WSIZE" // bit_wide(X)
#define  RPN32_TEXT_CODE_STR_PUSH       "PUSH"  // allocate (X) local regs


// Flags
//
#define  RPN32_TEXT_CODE_STR_SFLG       "SF"    // F[o]=1
#define  RPN32_TEXT_CODE_STR_CFLG       "CF"    // F[o]=0
#define  RPN32_TEXT_CODE_STR_XFLG       "XF"    // F[o]=!F[o]
#define  RPN32_TEXT_CODE_STR_VFLG       "F?"    // (F[o]!=0)->X


// Operace s pametovymi registry
//
#define  RPN32_TEXT_CODE_STR_STOADD     "STO+"  // R[o]+=X
#define  RPN32_TEXT_CODE_STR_STOSUB     "STO-"  // R[o]-=X
#define  RPN32_TEXT_CODE_STR_STOMUL     "STO*"  // R[o]*=X
#define  RPN32_TEXT_CODE_STR_STODIV     "STO/"  // R[o]/=X
#define  RPN32_TEXT_CODE_STR_STO        "STO"   // R[o]=X (store)
#define  RPN32_TEXT_CODE_STR_RCLADD     "RCL+"  // X+=R[o]
#define  RPN32_TEXT_CODE_STR_RCLSUB     "RCL-"  // X-=R[o]
#define  RPN32_TEXT_CODE_STR_RCLMUL     "RCL*"  // X*=R[o]
#define  RPN32_TEXT_CODE_STR_RCLDIV     "RCL/"  // X/=R[o]
#define  RPN32_TEXT_CODE_STR_RCL        "RCL"   // X=R[o] (recall)
#define  RPN32_TEXT_CODE_STR_XCH        "x<>"   // X<->R[o] (exchange)
#define  RPN32_TEXT_CODE_STR_INC        "INC"   // R[o]+=1
#define  RPN32_TEXT_CODE_STR_DEC        "DEC"   // R[o]-=1


// Vetveni programu
//
#define  RPN32_TEXT_CODE_STR_LBL        "LBL"   // label
#define  RPN32_TEXT_CODE_STR_GTO        "GTO"   // go to
#define  RPN32_TEXT_CODE_STR_XEQ        "XEQ"   // execute (go sub)
#define  RPN32_TEXT_CODE_STR_RTN        "RTN"   // return
#define  RPN32_TEXT_CODE_STR_EQ         "x=="   // X==Q
#define  RPN32_TEXT_CODE_STR_NE         "x!="   // X!=Q
#define  RPN32_TEXT_CODE_STR_LE         "x<="   // X<=Q
#define  RPN32_TEXT_CODE_STR_LT         "x<"    // X<Q
#define  RPN32_TEXT_CODE_STR_GE         "x>="   // X>=Q
#define  RPN32_TEXT_CODE_STR_GT         "x>"    // X>Q
#define  RPN32_TEXT_CODE_STR_BITSC      "BS?C"  // (Y&1<<X)!=0, clear
#define  RPN32_TEXT_CODE_STR_BITS       "BS?"   // (Y&1<<X)!=0
#define  RPN32_TEXT_CODE_STR_BITCC      "BC?C"  // (Y&1<<X)==0, clear
#define  RPN32_TEXT_CODE_STR_BITC       "BC?"   // (Y&1<<X)==0
#define  RPN32_TEXT_CODE_STR_FLGSC      "FS?C"  // F[o]!=0, clear
#define  RPN32_TEXT_CODE_STR_FLGS       "FS?"   // F[o]!=0
#define  RPN32_TEXT_CODE_STR_FLGCC      "FC?C"  // F[o]==0, clear
#define  RPN32_TEXT_CODE_STR_FLGC       "FC?"   // F[o]==0
#define  RPN32_TEXT_CODE_STR_ISG        "ISG"   // increment, skip if great
#define  RPN32_TEXT_CODE_STR_DSE        "DSE"   // decrement, skip if equal
#define  RPN32_TEXT_CODE_STR_ISZ        "ISZ"   // increment, skip if zero
#define  RPN32_TEXT_CODE_STR_DSZ        "DSZ"   // decrement, skip if zero


// Direktivy
//
#define  RPN32_TEXT_CODE_STR_STOP       "STOP"  // stop execute job
#define  RPN32_TEXT_CODE_STR_PSE        "PSE"   // pause, show intermediate data
#define  RPN32_TEXT_CODE_STR_SGN        "SGN"   // signed
#define  RPN32_TEXT_CODE_STR_UNS        "UNS"   // unsigned
#define  RPN32_TEXT_CODE_STR_WIDE       "WIDE"  // bit_wide {D | W | B}
#define  RPN32_TEXT_CODE_STR_IWSIZE     "IWSIZ" // bit_wide(I)
#define  RPN32_TEXT_CODE_STR_IPUSH      "IPUSH" // allocate (I) local regs
#define  RPN32_TEXT_CODE_STR_POP        "POP"   // free local regs


// Jmena registru RPN stacku + LASTx + Flags
//
#define  RPN32_TEXT_CODE_STR_REG_X      "X"
#define  RPN32_TEXT_CODE_STR_REG_Y      "Y"
#define  RPN32_TEXT_CODE_STR_REG_Z      "Z"
#define  RPN32_TEXT_CODE_STR_REG_T      "T"
#define  RPN32_TEXT_CODE_STR_REG_LASTX  "L"
#define  RPN32_TEXT_CODE_STR_REG_FLAGS  "F"


// Pseudoinstrukce (nastaveni max poctu pametovych registru a navratovych adres)
//
#define _RPN32_TEXT_PSEUDO_STR(k)       "?" _RPN32_MEM_TXTID_STR_##k
#define  RPN32_TEXT_PSEUDO_STR_REG      _RPN32_TEXT_PSEUDO_STR(REG)
#define  RPN32_TEXT_PSEUDO_STR_RTN      _RPN32_TEXT_PSEUDO_STR(RTN)
#define  RPN32_TEXT_PSEUDO_STR_LOC      _RPN32_TEXT_PSEUDO_STR(LOC)



/*----------------------------------------------------------------------------*\
                                    ZNAKY
\*----------------------------------------------------------------------------*/


// Operandy instrukci, oddelovace, ...
//
#define  RPN32_TEXT_CODE_CHR_BYTE       'B'
#define  RPN32_TEXT_CODE_CHR_WORD       'W'
#define  RPN32_TEXT_CODE_CHR_DWORD      'D'
#define  RPN32_TEXT_CODE_CHR_0          '0'
#define  RPN32_TEXT_CODE_CHR_Y          'y'
#define  RPN32_TEXT_CODE_CHR_CMPQMARK   '\?'
#define  RPN32_TEXT_CODE_CHR_LCN        ','
#define  RPN32_TEXT_CODE_CHR_INDIRECT   '@'
#define  RPN32_TEXT_CODE_STR_INDIRECT   "@"
#define  RPN32_TEXT_CODE_CHR_LOCREG     '.'
#define  RPN32_TEXT_CODE_STR_LOCREG     "."


// Adresa instrukce
//
#define  RPN32_TEXT_ADDR_CHR_UNKNOWN    'U'
#define  RPN32_TEXT_ADDR_CHR_SEPAR      ':'



/*----------------------------------------------------------------------------*/



#ifdef __cplusplus
}
#endif


#define _RPN32_H_INCLUDED
#endif