RPN32 - Header rpn32.h
Kapitola Co tam bylo a už není z úvodní stránky popisu inzeruje „pouhých“ 600 řádků obsažených v headeru rpn32.h. Nutno ještě podotknouti, jé je je, že třetinu z tohoto rozsahu zabírají definice symbolů zastupujícících textový tvar RPN instrukcí, jé je je. Z toho je jasně vidět, že i pro poměrně výkonný SW modul lze vytvořit jednoduchý interface. (S ohledem na přítomnost citátu klasika české literatury, jé je je, je patrně vhodnější na tomto místě užít slovní spojení programové rozhraní, jé je je :-)
#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