/Articles/Forth/HTML/WordList.en.html
0,0 → 1,1251
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title> Forth amforth </title>
<meta name="keywords" content="amforth programming language Forth ATmega ATMEL">
<meta name="description" content="amforth - laguage Forth for ATMEL ATmega">
<!-- AUTOINCLUDE START "Page/Head.en.ihtml" DO NOT REMOVE -->
<link rel="StyleSheet" href="../../../Web/CSS/MLAB.css" type="text/css" title="MLAB Basic Style">
<link rel="StyleSheet" href="../../../Web/CSS/MLAB_Print.css" type="text/css" media="print">
<link rel="shortcut icon" type="image/x-icon" href="../../../Web/PIC/MLAB.ico">
<script type="text/javascript" src="../../../Web/JS/MLAB_Menu.js"></script>
<!-- AUTOINCLUDE END -->
</head>
 
<body lang="en">
 
<!-- AUTOINCLUDE START "Page/Header.en.ihtml" DO NOT REMOVE -->
<!-- ============== HEADER ============== -->
<div class="Header">
<script type="text/javascript">
<!--
SetRelativePath("../../../");
DrawHeader();
// -->
</script>
<noscript>
<p><b> JavaScript is required for including of the header </b></p>
</noscript>
</div>
<!-- AUTOINCLUDE END -->
 
<!-- AUTOINCLUDE START "Page/Menu.en.ihtml" DO NOT REMOVE -->
<!-- ============== MENU ============== -->
<div class="Menu">
<script type="text/javascript">
<!--
SetRelativePath("../../../");
DrawMenu();
// -->
</script>
<noscript>
<p><b> JavaScript is required for including of the menu </b><p>
</noscript>
</div>
<!-- AUTOINCLUDE END -->
 
<!-- ============== TEXT ============== -->
<div class="Text">
<p class="Title">
amforth - Forth for ATmega
</p>
<p class="Subtitle">
This page provides cross reference of the language amforth. The list is
automaticaly generated drectly from assemble source files.
</p>
 
<h1> Vesion </h1>
 
<table class="Compact">
<tr>
<th colspan="2" class="center"> Basic information </th>
</tr>
<tr>
<td> amforth main page </td>
<td> <a href="http://amforth.sourceforge.net/">http://amforth.sourceforge.net/</a></td>
</tr>
<tr>
<td> amforth download page </td>
<td> <a href="http://sourceforge.net/projects/amforth">http://sourceforge.net/projects/amforth</a></td>
</tr>
<tr>
<td> Subversion server </td>
<td> <a href="https://amforth.svn.sourceforge.net/svnroot/amforth">https://amforth.svn.sourceforge.net/svnroot/amforth</a></td>
</tr>
<tr><th colspan="2">Subversion Info</th></tr><tr><td>URL</td><td> https://amforth.svn.sourceforge.net/svnroot/amforth/trunk</td></tr>
<tr><td>Repository Root</td><td> https://amforth.svn.sourceforge.net/svnroot/amforth</td></tr>
<tr><td>Repository UUID</td><td> 1be2a6a9-e81f-0410-9be0-e59bd151596a</td></tr>
<tr><td>Last Changed Author</td><td> mtrute</td></tr>
<tr><td>Last Changed Rev</td><td> 328</td></tr>
<tr><td>Last Changed Date</td><td> 2007-06-11 08:42:09 +0200 (Mon, 11 Jun 2007)</td></tr>
</table>
 
<!--
<<ReadMe>>
-->
 
<h1> Vocabulary </h1>
 
<table>
<tr>
<th>Word</th>
<th>Label</th>
<th>Definition</th>
</tr>
<tr>
<td>!</td>
<td><a href="CodeAsm/store.html#STORE" title="VE_STORE">STORE</a></td>
<td>( n addr -- ) Memory<br>R( -- )<br>write 16bit to RAM memory (or IO or CPU registers)</td>
</tr>
<tr>
<td>#</td>
<td><a href="CodeAsm/sharp.html#SHARP" title="VE_SHARP">SHARP</a></td>
<td>( d1 -- d2) Numeric IO<br>R( -- )<br>compiles next digit to HLD</td>
</tr>
<tr>
<td>#&gt;</td>
<td><a href="CodeAsm/sharp_g.html#SHARP_G" title="VE_SHARP_G">SHARP_G</a></td>
<td>( d1 -- addr count ) Numeric IO<br>R( -- )<br>convert HLD buffer to a usable string</td>
</tr>
<tr>
<td>#int</td>
<td><a href="CodeAsm/intx.html#NUMINT" title="VE_NUMINT">NUMINT</a></td>
<td>( -- n ) Interrupt<br>R( -- )<br>number of interrupt vectors (0 based)</td>
</tr>
<tr>
<td>#s</td>
<td><a href="CodeAsm/sharp_s.html#SHARP_S" title="VE_SHARP_S">SHARP_S</a></td>
<td>( d1 -- 0) Numeric IO<br>R( -- )<br>call # until a value of zero is reached</td>
</tr>
<tr>
<td>#tib</td>
<td><a href="CodeAsm/sharptib.html#NUMBERTIB" title="VE_NUMBERTIB">NUMBERTIB</a></td>
<td>( -- addr ) System<br>R( -- )<br>address of variable holding the number of characters in TIB</td>
</tr>
<tr>
<td>'</td>
<td><a href="CodeAsm/tick.html#TICK" title="VE_TICK">TICK</a></td>
<td>( -- XT ) Dictionary<br>R( -- )<br>search dictionary, returns XT or throw an exception -13</td>
</tr>
<tr>
<td>(</td>
<td><a href="CodeAsm/lparenthesis.html#LPARENTHESIS" title="VE_LPARENTHESIS">LPARENTHESIS</a></td>
<td>( -- ) Compiler<br>R( -- )<br>skip everything up to the closing bracket on the same line</td>
</tr>
<tr>
<td>*</td>
<td><a href="CodeAsm/star.html#MUL" title="VE_MUL">MUL</a></td>
<td>( n1 n2 -- n3 ) Arithmetics<br>R( -- )<br>multiply routine</td>
</tr>
<tr>
<td>*/</td>
<td><a href="CodeAsm/starslash.html#STARSLASH" title="VE_STARSLASH">STARSLASH</a></td>
<td>(n1 n2 n3 -- n4) Arithmetics<br>R( -- )<br>signed multiply and division with double precision intermediate</td>
</tr>
<tr>
<td>*/mod</td>
<td><a href="CodeAsm/starslashmod.html#STARSLASHMOD" title="VE_STARSLASHMOD">STARSLASHMOD</a></td>
<td>( n1 n2 n3 -- rem quot) Arithmetics<br>R( -- )<br>signed multiply and division with double precision intermediate and remainder</td>
</tr>
<tr>
<td>+</td>
<td><a href="CodeAsm/plus.html#PLUS" title="VE_PLUS">PLUS</a></td>
<td>( n1 n2 -- n3) Arithmetics<br>R( -- )<br>addition</td>
</tr>
<tr>
<td>+!</td>
<td><a href="CodeAsm/plusstore.html#PLUSSTORE" title="VE_PLUSSTORE">PLUSSTORE</a></td>
<td>( n addr -- ) Arithmetics<br>R( -- )<br>add value to content of RAM address</td>
</tr>
<tr>
<td>+loop</td>
<td><a href="CodeAsm/plusloop.html#PLOOP" title="VE_PLOOP">PLOOP</a></td>
<td>( addr -- ) Control Structure<br>R( -- )<br>compile +loop and resolve branch</td>
</tr>
<tr>
<td>,</td>
<td><a href="CodeAsm/comma.html#COMMA" title="VE_COMMA">COMMA</a></td>
<td>( n -- ) Dictionary<br>R( -- )<br>compile 16 bit into flash at here.</td>
</tr>
<tr>
<td>-</td>
<td><a href="CodeAsm/minus.html#MINUS" title="VE_MINUS">MINUS</a></td>
<td>( n1 n2 -- n3 ) Arithmetics<br>R( -- )<br>subtract</td>
</tr>
<tr>
<td>.</td>
<td><a href="CodeAsm/dot.html#DOT" title="VE_DOT">DOT</a></td>
<td>( n -- ) Numeric IO<br>R( -- )<br>prints TOS in free number format</td>
</tr>
<tr>
<td>.&quot;</td>
<td><a href="CodeAsm/dotstring.html#DOTSTRING" title="VE_DOTSTRING">DOTSTRING</a></td>
<td>( -- ) Compiler<br>R( -- )<br>compiles string into dictionary to be typed at runtime</td>
</tr>
<tr>
<td>.&quot;</td>
<td><a href="CodeAsm/dotstring.html#DOTSTRING" title="VE_DOTSTRING">DOTSTRING</a></td>
<td>( -- ) Compiler<br>R( -- )<br>compiles string into dictionary to be typed at runtime</td>
</tr>
<tr>
<td>.s</td>
<td><a href="CodeAsm/dot-s.html#DOTS" title="VE_DOTS">DOTS</a></td>
<td>( -- ) Tools<br>R( -- )<br>stack dump</td>
</tr>
<tr>
<td>.s</td>
<td><a href="CodeAsm/dot-s.html#DOTS" title="VE_DOTS">DOTS</a></td>
<td>( -- ) Tools<br>R( -- )<br>stack dump</td>
</tr>
<tr>
<td>/</td>
<td><a href="CodeAsm/slash.html#SLASH" title="VE_SLASH">SLASH</a></td>
<td>( n1 n2 -- n3) Arithmetics<br>R( -- )<br>diviion</td>
</tr>
<tr>
<td>/int</td>
<td><a href="CodeAsm/intx.html#INTOFF" title="VE_INTOFF">INTOFF</a></td>
<td>( -- sreg ) Interrupt<br>R( -- )<br>turns off all interrupts and leaves SREG in TOS</td>
</tr>
<tr>
<td>/key</td>
<td><a href="CodeAsm/slashkey.html#SLASHKEY" title="VE_SLASHKEY">SLASHKEY</a></td>
<td>( -- f) Character IO<br>R( -- )<br>fetch 'key? vector and execute it if not zero. Leave true if a character can be read, false otherwise</td>
</tr>
<tr>
<td>/mod</td>
<td><a href="CodeAsm/slashmod.html#SLASHMOD" title="VE_SLASHMOD">SLASHMOD</a></td>
<td>( n1 n2 -- rem quot) Arithmetics<br>R( -- )<br>signed division n1/n2 with remainder</td>
</tr>
<tr>
<td>/string</td>
<td><a href="CodeAsm/slashstring.html#SLASHSTRING" title="VE_SLASHSTRING">SLASHSTRING</a></td>
<td>( addr1 u1 n-- addr2 u2 ) String<br>R( -- )<br>adjust string from addr1 to addr1+n, reduce length from u1 to u2</td>
</tr>
<tr>
<td>0</td>
<td><a href="CodeAsm/zero.html#ZERO" title="VE_ZERO">ZERO</a></td>
<td>( -- 0 ) Arithmetics<br>R( -- )<br>leaves the value 0 on TOS</td>
</tr>
<tr>
<td>0&lt;</td>
<td><a href="CodeAsm/lesszero.html#LESSZERO" title="VE_LESSZERO">LESSZERO</a></td>
<td>( n1 -- flag) Compare<br>R( -- )<br>compare with zero</td>
</tr>
<tr>
<td>0&lt;&gt;</td>
<td><a href="CodeAsm/notequalzero.html#NOTEQUALZERO" title="VE_NOTEQUALZERO">NOTEQUALZERO</a></td>
<td>( n -- flag ) Compare<br>R( -- )<br>compare with zero</td>
</tr>
<tr>
<td>0=</td>
<td><a href="CodeAsm/equalzero.html#EQUALZERO" title="VE_EQUALZERO">EQUALZERO</a></td>
<td>( n -- flag ) Compare<br>R( -- )<br>compare with 0 (zero)</td>
</tr>
<tr>
<td>0&gt;</td>
<td><a href="CodeAsm/greaterzero.html#GREATERZERO" title="VE_GREATERZERO">GREATERZERO</a></td>
<td>( n1 -- flag ) Compare<br>R( -- )<br>compare with zero</td>
</tr>
<tr>
<td>1+</td>
<td><a href="CodeAsm/1plus.html#1PLUS" title="VE_1PLUS">1PLUS</a></td>
<td>( n1 -- n2 ) Arithmetics<br>R( -- )<br>optimized increment</td>
</tr>
<tr>
<td>1-</td>
<td><a href="CodeAsm/1minus.html#1MINUS" title="VE_1MINUS">1MINUS</a></td>
<td>( n1 -- n2 ) Arithmetics<br>R( -- )<br>optimized decrement (CORE)</td>
</tr>
<tr>
<td>1ms</td>
<td><a href="CodeAsm/1ms.html#1MS" title="VE_1MS">1MS</a></td>
<td>( -- ) Time<br>R(--)<br>busy waits (almost) exactly 1 millisecond</td>
</tr>
<tr>
<td>2*</td>
<td><a href="CodeAsm/2star.html#2STAR" title="VE_2STAR">2STAR</a></td>
<td>( n1 -- n2 ) Arithmetics<br>R( -- )<br>arithmetic shift left</td>
</tr>
<tr>
<td>2/</td>
<td><a href="CodeAsm/2slash.html#2SLASH" title="VE_2SLASH">2SLASH</a></td>
<td>( n1 -- n2 ) Arithmetics<br>R( -- )<br>arithmetic shift right</td>
</tr>
<tr>
<td>:</td>
<td><a href="CodeAsm/colon.html#COLON" title="VE_COLON">COLON</a></td>
<td>( -- ) Compiler<br>R( -- )<br>create named entry in the dictionary</td>
</tr>
<tr>
<td>:noname</td>
<td><a href="CodeAsm/colon-noname.html#COLONNONAME" title="VE_COLONNONAME">COLONNONAME</a></td>
<td>( -- xt ) Compiler<br>R( -- )<br>create unnamed entry in the dictionary</td>
</tr>
<tr>
<td>;</td>
<td><a href="CodeAsm/semicolon.html#SEMICOLON" title="VE_SEMICOLON">SEMICOLON</a></td>
<td>( -- ) Compiler<br>R( -- )<br>finish colon defintion, compiles (exit) and returns to interpreter state</td>
</tr>
<tr>
<td>&lt;</td>
<td><a href="CodeAsm/less.html#LESS" title="VE_LESS">LESS</a></td>
<td>( n1 n2 -- flasg) Compare<br>R( -- )<br>compare two values</td>
</tr>
<tr>
<td>&lt;#</td>
<td><a href="CodeAsm/l_sharp.html#L_SHARP" title="VE_L_SHARP">L_SHARP</a></td>
<td>( -- ) Numeric IO<br>R( -- )<br>emties counted string at address from hld</td>
</tr>
<tr>
<td>&lt;&gt;</td>
<td><a href="CodeAsm/notequal.html#NOTEQUAL" title="VE_NOTEQUAL">NOTEQUAL</a></td>
<td>( n1 n2 -- flag) Compare<br>R( -- )<br>compare two values</td>
</tr>
<tr>
<td>=</td>
<td><a href="CodeAsm/equal.html#EQUAL" title="VE_EQUAL">EQUAL</a></td>
<td>( n1 n2 -- flag ) Compare<br>R( -- )<br>compares two values</td>
</tr>
<tr>
<td>&gt;</td>
<td><a href="CodeAsm/greater.html#GREATER" title="VE_GREATER">GREATER</a></td>
<td>( n1 n2 -- flag ) Compare<br>R( -- )<br>compares two values (signed)</td>
</tr>
<tr>
<td>&gt;&lt;</td>
<td><a href="CodeAsm/byteswap.html#BYTESWAP" title="VE_BYTESWAP">BYTESWAP</a></td>
<td>( n1 -- n2 ) Arithmetics<br>R( -- )<br>swap the bytes of the TOS</td>
</tr>
<tr>
<td>&gt;in</td>
<td><a href="CodeAsm/g_in.html#G_IN" title="VE_G_IN">G_IN</a></td>
<td>( -- addr ) System<br>R( -- )<br>pointer to current read position in TIB</td>
</tr>
<tr>
<td>&gt;r</td>
<td><a href="CodeAsm/to_r.html#TO_R" title="VE_TO_R">TO_R</a></td>
<td>( n -- ) Stack<br>R( -- n)<br>move TOS to TOR</td>
</tr>
<tr>
<td>?do</td>
<td><a href="CodeAsm/qdo.html#QDO" title="VE_QDO">QDO</a></td>
<td>( -- addr ) Control Structure<br>R( -- )<br>start do .. [+]loop</td>
</tr>
<tr>
<td>?do</td>
<td><a href="CodeAsm/qdo.html#QDO" title="VE_QDO">QDO</a></td>
<td>( -- addr ) Control Structure<br>R( -- )<br>start do .. [+]loop</td>
</tr>
<tr>
<td>?dup</td>
<td><a href="CodeAsm/qdup.html#QDUP" title="VE_QDUP">QDUP</a></td>
<td>( n1 -- [ n1 n1 ] | 0) Stack<br>R( -- )<br>duplicate TOS if non-zero</td>
</tr>
<tr>
<td>@</td>
<td><a href="CodeAsm/fetch.html#FETCH" title="VE_FETCH">FETCH</a></td>
<td>( addr -- n ) Memory<br>R( -- )<br>read 1 cell from RAM (or IO or CPU register)</td>
</tr>
<tr>
<td>Edefer</td>
<td><a href="CodeAsm/edefer.html#EDEFER" title="VE_EDEFER">EDEFER</a></td>
<td>( n &lt;name&gt; -- ) Compiler<br>R( -- )<br>creates a defer vector which is kept in eeprom.</td>
</tr>
<tr>
<td>Edefer</td>
<td><a href="CodeAsm/edefer.html#EDEFER" title="VE_EDEFER">EDEFER</a></td>
<td>( n &lt;name&gt; -- ) Compiler<br>R( -- )<br>creates a defer vector which is kept in eeprom.</td>
</tr>
<tr>
<td>Rdefer</td>
<td><a href="CodeAsm/rdefer.html#RDEFER" title="VE_RDEFER">RDEFER</a></td>
<td>( n &lt;name&gt; -- ) Compiler<br>R( -- )<br>creates a RAM based defer vector</td>
</tr>
<tr>
<td>Rdefer</td>
<td><a href="CodeAsm/rdefer.html#RDEFER" title="VE_RDEFER">RDEFER</a></td>
<td>( n &lt;name&gt; -- ) Compiler<br>R( -- )<br>creates a RAM based defer vector</td>
</tr>
<tr>
<td>[</td>
<td><a href="CodeAsm/leftbracket.html#LBRACKET" title="VE_LBRACKET">LBRACKET</a></td>
<td>( -- ) Compiler<br>R( -- )<br>put system to interpreter state</td>
</tr>
<tr>
<td>[']</td>
<td><a href="CodeAsm/brackettick.html#BRACKETTICK" title="VE_BRACKETTICK">BRACKETTICK</a></td>
<td>( -- XT ) Compiler<br>R( -- )<br>what does ' in the interpreter mode do in colon definitions</td>
</tr>
<tr>
<td>\</td>
<td><a href="CodeAsm/backslash.html#BACKSLASH" title="VE_BACKSLASH">BACKSLASH</a></td>
<td>( -- ) Compiler<br>R( -- )<br>everything up to the end of the current line is a comment</td>
</tr>
<tr>
<td>]</td>
<td><a href="CodeAsm/rightbracket.html#RBRACKET" title="VE_RBRACKET">RBRACKET</a></td>
<td>( -- ) Compiler<br>R( -- )<br>turn on compiler</td>
</tr>
<tr>
<td>abort</td>
<td><a href="CodeAsm/abort.html#ABORT" title="VE_ABORT">ABORT</a></td>
<td>( n*x -- ) Exceptions<br>R( n*y -- )<br>send an exception -1</td>
</tr>
<tr>
<td>abort&quot;</td>
<td><a href="CodeAsm/abortstring.html#ABORTSTRING" title="VE_ABORTSTRING">ABORTSTRING</a></td>
<td>( n*x -- ) Exceptions<br>R( n*y -- )<br>check flag. If true emit some text and throw exception -2</td>
</tr>
<tr>
<td>abort&quot;</td>
<td><a href="CodeAsm/abortstring.html#ABORTSTRING" title="VE_ABORTSTRING">ABORTSTRING</a></td>
<td>( n*x -- ) Exceptions<br>R( n*y -- )<br>check flag. If true emit some text and throw exception -2</td>
</tr>
<tr>
<td>abs</td>
<td><a href="CodeAsm/abs.html#ABS" title="VE_ABS">ABS</a></td>
<td>( n1 -- u1 ) Arithmetics<br>R( -- )<br>get the absolute value</td>
</tr>
<tr>
<td>accept</td>
<td><a href="CodeAsm/accept.html#ACCEPT" title="VE_ACCEPT">ACCEPT</a></td>
<td>( addr n1 -- n2 ) System<br>R( -- )<br>reads a line with with KEY into addr until n2 characters are reveived or cr/lf detected.</td>
</tr>
<tr>
<td>again</td>
<td><a href="CodeAsm/again.html#AGAIN" title="VE_AGAIN">AGAIN</a></td>
<td>( addr -- ) Control Structure<br>R( -- )<br>go back to begin</td>
</tr>
<tr>
<td>allot</td>
<td><a href="CodeAsm/allot.html#ALLOT" title="VE_ALLOT">ALLOT</a></td>
<td>( n -- ) System<br>R( -- )<br>allocate memory in RAM</td>
</tr>
<tr>
<td>and</td>
<td><a href="CodeAsm/and.html#AND" title="VE_AND">AND</a></td>
<td>( n1 n2 -- n3 ) Logic<br>R( -- )<br>bitwise and</td>
</tr>
<tr>
<td>base</td>
<td><a href="CodeAsm/base.html#BASE" title="VE_BASE">BASE</a></td>
<td>( -- addr ) Numeric IO<br>R( -- )<br>base fo numeric IO</td>
</tr>
<tr>
<td>baud0</td>
<td><a href="CodeAsm/usart.html#BAUD0" title="VE_BAUD0">BAUD0</a></td>
<td>( -- v) System Value<br>R( -- )<br>returns usart0 baudrate</td>
</tr>
<tr>
<td>begin</td>
<td><a href="CodeAsm/begin.html#BEGIN" title="VE_BEGIN">BEGIN</a></td>
<td>( -- addr ) Control Structure<br>R( -- )<br>start a control structture</td>
</tr>
<tr>
<td>bl</td>
<td><a href="CodeAsm/bl.html#BL" title="VE_BL">BL</a></td>
<td>( -- 32 ) Character IO<br>R( -- )<br>put ascii code of the blank to the stack</td>
</tr>
<tr>
<td>c!</td>
<td><a href="CodeAsm/cstore.html#CSTORE" title="VE_CSTORE">CSTORE</a></td>
<td>( c addr -- ) Memory<br>R( -- )<br>store a byte to RAM address</td>
</tr>
<tr>
<td>c@</td>
<td><a href="CodeAsm/cfetch.html#CFETCH" title="VE_CFETCH">CFETCH</a></td>
<td>( addr - c1 ) Memory<br>R( -- )<br>fetch a single byte from RAM (or IO or CPU register)</td>
</tr>
<tr>
<td>case</td>
<td><a href="CodeAsm/case.html#CASE" title="VE_CASE">CASE</a></td>
<td>( -- 0 ) Control Structure<br>R( -- )</td>
</tr>
<tr>
<td>case</td>
<td><a href="CodeAsm/case.html#CASE" title="VE_CASE">CASE</a></td>
<td>( -- 0 ) Control Structure<br>R( -- )</td>
</tr>
<tr>
<td>catch</td>
<td><a href="CodeAsm/catch.html#CATCH" title="VE_CATCH">CATCH</a></td>
<td>( xt -- ) Exceptions<br>R( -- ) or R( ny -- )<br>execute the XT and restore stack frame if an exception is thrown</td>
</tr>
<tr>
<td>char</td>
<td><a href="CodeAsm/char.html#CHAR" title="VE_CHAR">CHAR</a></td>
<td>( -- c ) Tools<br>R( -- )<br>first character of the next word</td>
</tr>
<tr>
<td>cmove&gt;</td>
<td><a href="CodeAsm/cmove_g.html#CMOVE_G" title="VE_CMOVE_G">CMOVE_G</a></td>
<td>(addr-from addr-to n -- ) Memory<br>R( -- )<br>copy data in RAM</td>
</tr>
<tr>
<td>cold</td>
<td><a href="CodeAsm/cold.html#COLD" title="VE_COLD">COLD</a></td>
<td>( -- ) System<br>R( -- )<br>main entry word. executes turnkey operation and executes quit</td>
</tr>
<tr>
<td>compile</td>
<td><a href="CodeAsm/compile.html#COMPILE" title="VE_COMPILE">COMPILE</a></td>
<td>( -- ) Dictionary<br>R( -- )<br>copy the next flash cell to HERE</td>
</tr>
<tr>
<td>constant</td>
<td><a href="CodeAsm/constant.html#CONSTANT" title="VE_CONSTANT">CONSTANT</a></td>
<td>( n -- ) Compiler<br>R( -- )<br>create a named constant</td>
</tr>
<tr>
<td>count</td>
<td><a href="CodeAsm/count.html#COUNT" title="VE_COUNT">COUNT</a></td>
<td>( addr -- addr+1 n) String<br>R( -- )<br>addr is the address of a counted string in RAM</td>
</tr>
<tr>
<td>cr</td>
<td><a href="CodeAsm/cr.html#CR" title="VE_CR">CR</a></td>
<td>( -- ) Character IO<br>R( -- )<br>emits CR/LF</td>
</tr>
<tr>
<td>create</td>
<td><a href="CodeAsm/create.html#CREATE" title="VE_CREATE">CREATE</a></td>
<td>( -- ) Dictionary<br>R( -- )<br>create a complete dictionary header.</td>
</tr>
<tr>
<td>cscan</td>
<td><a href="CodeAsm/char-scan.html#CSCAN" title="VE_CSCAN">CSCAN</a></td>
<td>( addr1 n1 c -- addr1 n2 ) String<br>R( -- )<br>Scan string at addr1/n1 until first c, leaving addr1/n2, char at n2 is last non-c character</td>
</tr>
<tr>
<td>cskip</td>
<td><a href="CodeAsm/char-skip.html#CSKIP" title="VE_CSKIP">CSKIP</a></td>
<td>( addr1 n1 c -- addr2 n2 ) String<br>R( -- )<br>skips leading occurancies in string at addr1/n1 leaving addr2/n2 pointing to the 1st non-c character</td>
</tr>
<tr>
<td>d+</td>
<td><a href="CodeAsm/d-plus.html#DPLUS" title="VE_DPLUS">DPLUS</a></td>
<td>( d1 d2 -- d3) Arithmetics<br>R( -- )<br>add double cell values</td>
</tr>
<tr>
<td>d+</td>
<td><a href="CodeAsm/d-plus.html#DPLUS" title="VE_DPLUS">DPLUS</a></td>
<td>( d1 d2 -- d3) Arithmetics<br>R( -- )<br>add double cell values</td>
</tr>
<tr>
<td>d-</td>
<td><a href="CodeAsm/d-minus.html#DMINUS" title="VE_DMINUS">DMINUS</a></td>
<td>( d1 d2 -- d3 ) Arithmetics<br>R( -- )<br>subtract double cell values</td>
</tr>
<tr>
<td>d-</td>
<td><a href="CodeAsm/d-minus.html#DMINUS" title="VE_DMINUS">DMINUS</a></td>
<td>( d1 d2 -- d3 ) Arithmetics<br>R( -- )<br>subtract double cell values</td>
</tr>
<tr>
<td>d2*</td>
<td><a href="CodeAsm/d-2star.html#D2STAR" title="VE_D2STAR">D2STAR</a></td>
<td>( d1 -- d2 ) Arithmetics<br>R( -- )<br>shift a double cell left</td>
</tr>
<tr>
<td>d2*</td>
<td><a href="CodeAsm/d-2star.html#D2STAR" title="VE_D2STAR">D2STAR</a></td>
<td>( d1 -- d2 ) Arithmetics<br>R( -- )<br>shift a double cell left</td>
</tr>
<tr>
<td>d2/</td>
<td><a href="CodeAsm/d-2slash.html#D2SLASH" title="VE_D2SLASH">D2SLASH</a></td>
<td>( d1 -- d2 ) Arithmetics<br>R( -- )<br>shift a double cell value right</td>
</tr>
<tr>
<td>d&lt;</td>
<td><a href="CodeAsm/d-less.html#DLESS" title="VE_DLESS">DLESS</a></td>
<td>( d1 d2 -- flasg) Compare<br>R( -- )<br>compare two values</td>
</tr>
<tr>
<td>d&gt;</td>
<td><a href="CodeAsm/d-greater.html#DGREATER" title="VE_DGREATER">DGREATER</a></td>
<td>( d1 d2 -- flag ) Compare<br>R( -- )<br>compares two values (signed)</td>
</tr>
<tr>
<td>d&gt;s</td>
<td><a href="CodeAsm/d_to_s.html#D2S" title="VE_D2S">D2S</a></td>
<td>( d1 -- n1 ) Conversion<br>R( -- )<br>shrink double cell value to single cell.</td>
</tr>
<tr>
<td>decimal</td>
<td><a href="CodeAsm/decimal.html#DECIMAL" title="VE_DECIMAL">DECIMAL</a></td>
<td>( -- ) Numeric IO<br>R( -- )<br>set base to 10 (decimal)</td>
</tr>
<tr>
<td>defer!</td>
<td><a href="CodeAsm/defer-store.html#DEFERSTORE" title="VE_DEFERSTORE">DEFERSTORE</a></td>
<td>( xt1 xt2 -- ) System<br>R( -- )<br>stores xt1 as the xt to be executed when xt2 is called</td>
</tr>
<tr>
<td>defer@</td>
<td><a href="CodeAsm/defer-fetch.html#DEFERFETCH" title="VE_DEFERFETCH">DEFERFETCH</a></td>
<td>( xt1 -- xt2 ) System<br>R( -- )<br>returns the XT assoziates with the given XT</td>
</tr>
<tr>
<td>depth</td>
<td><a href="CodeAsm/depth.html#DEPTH" title="VE_DEPTH">DEPTH</a></td>
<td>( -- n ) Stack<br>R( -- )<br>currently used data stack size in cells</td>
</tr>
<tr>
<td>digit</td>
<td><a href="CodeAsm/digit.html#DIGIT" title="VE_DIGIT">DIGIT</a></td>
<td>( c base -- number flag ) Numeric IO<br>R( -- )<br>convert character to number, set flag if successful</td>
</tr>
<tr>
<td>dinvert</td>
<td><a href="CodeAsm/d-invert.html#DINVERT" title="VE_DINVERT">DINVERT</a></td>
<td>( d1 -- d2) Arithmetics<br>R( -- )<br>flip all bits in the double cell value</td>
</tr>
<tr>
<td>dinvert</td>
<td><a href="CodeAsm/d-invert.html#DINVERT" title="VE_DINVERT">DINVERT</a></td>
<td>( d1 -- d2) Arithmetics<br>R( -- )<br>flip all bits in the double cell value</td>
</tr>
<tr>
<td>do</td>
<td><a href="CodeAsm/do.html#DO" title="VE_DO">DO</a></td>
<td>( -- addr ) Control Structure<br>R( -- )<br>start do .. [+]loop</td>
</tr>
<tr>
<td>does&gt;</td>
<td><a href="CodeAsm/does.html#DOES" title="VE_DOES">DOES</a></td>
<td>( -- ) Compiler<br>R( -- )</td>
</tr>
<tr>
<td>dp</td>
<td><a href="CodeAsm/dp.html#DP" title="VE_DP">DP</a></td>
<td>( -- eaddr) System Pointer<br>R( -- )<br>first unused address in flash (NRWW is always used)</td>
</tr>
<tr>
<td>drop</td>
<td><a href="CodeAsm/drop.html#DROP" title="VE_DROP">DROP</a></td>
<td>( n -- ) Stack<br>R( -- )<br>drop TOS</td>
</tr>
<tr>
<td>dup</td>
<td><a href="CodeAsm/dup.html#DUP" title="VE_DUP">DUP</a></td>
<td>( n -- n n ) Stack<br>R( -- )<br>duplicate TOS</td>
</tr>
<tr>
<td>e!</td>
<td><a href="CodeAsm/estore.html#ESTORE" title="VE_ESTORE">ESTORE</a></td>
<td>( n addr -- ) Memory<br>R( -- )<br>write to eeprom address</td>
</tr>
<tr>
<td>e@</td>
<td><a href="CodeAsm/efetch.html#EFETCH" title="VE_EFETCH">EFETCH</a></td>
<td>( addr - n) Memory<br>R( -- )<br>read 2 bytes from eeprom</td>
</tr>
<tr>
<td>edp</td>
<td><a href="CodeAsm/edp.html#EDP" title="VE_EDP">EDP</a></td>
<td>( -- eaddr) System Pointer<br>R( -- )<br>first unused address in eeprom</td>
</tr>
<tr>
<td>else</td>
<td><a href="CodeAsm/else.html#ELSE" title="VE_ELSE">ELSE</a></td>
<td>( addr1 -- addr2) Compiler<br>R( -- )</td>
</tr>
<tr>
<td>emit</td>
<td><a href="CodeAsm/emit.html#EMIT" title="VE_EMIT">EMIT</a></td>
<td>( -- eaddr) Character IO<br>R( -- )<br>fetch the emit vector and execute it</td>
</tr>
<tr>
<td>emit?</td>
<td><a href="CodeAsm/emitq.html#EMITQ" title="VE_EMITQ">EMITQ</a></td>
<td>( -- c) Character IO<br>R( -- )<br>fetch emit? vector and execute it</td>
</tr>
<tr>
<td>endcase</td>
<td><a href="CodeAsm/endcase.html#ENDCASE" title="VE_ENDCASE">ENDCASE</a></td>
<td>( f -- ) Compiler<br>R( -- )</td>
</tr>
<tr>
<td>endcase</td>
<td><a href="CodeAsm/endcase.html#ENDCASE" title="VE_ENDCASE">ENDCASE</a></td>
<td>( f -- ) Compiler<br>R( -- )</td>
</tr>
<tr>
<td>endof</td>
<td><a href="CodeAsm/endof.html#ENDOF" title="VE_ENDOF">ENDOF</a></td>
<td>( addr1 -- addr2 ) Compiler<br>R( -- )</td>
</tr>
<tr>
<td>endof</td>
<td><a href="CodeAsm/endof.html#ENDOF" title="VE_ENDOF">ENDOF</a></td>
<td>( addr1 -- addr2 ) Compiler<br>R( -- )</td>
</tr>
<tr>
<td>execute</td>
<td><a href="CodeAsm/execute.html#EXECUTE" title="VE_EXECUTE">EXECUTE</a></td>
<td>( xt -- ) System<br>R( -- )<br>execute XT</td>
</tr>
<tr>
<td>exit</td>
<td><a href="CodeAsm/exit.html#EXIT" title="VE_EXIT">EXIT</a></td>
<td>( -- ) Compiler<br>R( xt -- )<br>end of current colon word</td>
</tr>
<tr>
<td>f_cpu</td>
<td><a href="CodeAsm/f_cpu.html#F_CPU" title="VE_F_CPU">F_CPU</a></td>
<td>( -- f_cou ) System<br>R( -- )<br>put the cpu frequency on stack</td>
</tr>
<tr>
<td>find</td>
<td><a href="CodeAsm/find.html#FIND" title="VE_FIND">FIND</a></td>
<td>( addr -- -- [ addr 0 ] | [ xt [-1|1]] ) Tools<br>R( -- )<br>search dictionary</td>
</tr>
<tr>
<td>handler</td>
<td><a href="CodeAsm/handler.html#HANDLER" title="VE_HANDLER">HANDLER</a></td>
<td>( -- addr ) Exceptions<br>R( -- )<br>used by catch/throw</td>
</tr>
<tr>
<td>heap</td>
<td><a href="CodeAsm/heap.html#HEAP" title="VE_HEAP">HEAP</a></td>
<td>( -- eaddr) System Pointer<br>R( -- )<br> address of first unallocated RAM</td>
</tr>
<tr>
<td>here</td>
<td><a href="CodeAsm/here.html#HERE" title="VE_HERE">HERE</a></td>
<td>( -- addr ) System Pointer<br>R( -- )</td>
</tr>
<tr>
<td>hex</td>
<td><a href="CodeAsm/hex.html#HEX" title="VE_HEX">HEX</a></td>
<td>( -- ) Numeric IO<br>R( -- )<br>set base to 16 (decimal)</td>
</tr>
<tr>
<td>hld</td>
<td><a href="CodeAsm/hld.html#HLD" title="VE_HLD">HLD</a></td>
<td>( -- addr ) Numeric IO<br>R( -- )<br>address of buffer for pictured numeric output</td>
</tr>
<tr>
<td>hold</td>
<td><a href="CodeAsm/hold.html#HOLD" title="VE_HOLD">HOLD</a></td>
<td>( c -- ) Numeric IO<br>R( -- )<br>prepend character to pictured numeric output buffer</td>
</tr>
<tr>
<td>i</td>
<td><a href="CodeAsm/i.html#I" title="VE_I">I</a></td>
<td>( -- n ) Control Structure<br>R( loop-sys -- loop-sys)<br>current loop counter</td>
</tr>
<tr>
<td>i!</td>
<td><a href="CodeAsm/istore.html#ISTORE" title="VE_ISTORE">ISTORE</a></td>
<td>( n addr -- ) Memory<br>R( -- )<br>writes a cell in flash</td>
</tr>
<tr>
<td>i@</td>
<td><a href="CodeAsm/ifetch.html#IFETCH" title="VE_IFETCH">IFETCH</a></td>
<td>( addr -- n1 ) Memory<br>R( -- )<br>reads a cell from flash, addr is cell address, not byte addres first byte gets into the lower word on tos</td>
</tr>
<tr>
<td>icount</td>
<td><a href="CodeAsm/icount.html#ICOUNT" title="VE_ICOUNT">ICOUNT</a></td>
<td>( adr -- adr n ) Tools<br>R( -- )<br>get count byte out of packed counted string in flash</td>
</tr>
<tr>
<td>idump</td>
<td><a href="CodeAsm/idump.html#IDUMP" title="VE_IDUMP">IDUMP</a></td>
<td>( addr len -- ) Tools<br>R( -- )<br>dumps flash memory beginning with address addr and len cells long</td>
</tr>
<tr>
<td>idump</td>
<td><a href="CodeAsm/idump.html#IDUMP" title="VE_IDUMP">IDUMP</a></td>
<td>( addr len -- ) Tools<br>R( -- )<br>dumps flash memory beginning with address addr and len cells long</td>
</tr>
<tr>
<td>if</td>
<td><a href="CodeAsm/if.html#IF" title="VE_IF">IF</a></td>
<td>( -- addr ) Control Structure<br>R( -- )<br>start conditional branch</td>
</tr>
<tr>
<td>immediate</td>
<td><a href="CodeAsm/immediate.html#IMMEDIATE" title="VE_IMMEDIATE">IMMEDIATE</a></td>
<td>( -- ) Compiler<br>R( -- )<br>set immediate flag</td>
</tr>
<tr>
<td>int</td>
<td><a href="CodeAsm/intx.html#INTON" title="VE_INTON">INTON</a></td>
<td>( -- ) Interrupt<br>R( -- )<br>turns on all interrupts</td>
</tr>
<tr>
<td>int!</td>
<td><a href="CodeAsm/intx.html#INTSTORE" title="VE_INTSTORE">INTSTORE</a></td>
<td>( xt i -- ) Interrupt<br>R( -- )<br>stores XT as interrupt vector i</td>
</tr>
<tr>
<td>int@</td>
<td><a href="CodeAsm/intx.html#INTFETCH" title="VE_INTFETCH">INTFETCH</a></td>
<td>( i -- xt ) Interrupt<br>R( -- )<br>fetches XT from interrupt vector i</td>
</tr>
<tr>
<td>interpret</td>
<td><a href="CodeAsm/interpret.html#INTERPRET" title="VE_INTERPRET">INTERPRET</a></td>
<td>( -- ) System<br>R(i*x - j*x )<br>interpret input word by word. may throw exceptions</td>
</tr>
<tr>
<td>invert</td>
<td><a href="CodeAsm/invert.html#INVERT" title="VE_INVERT">INVERT</a></td>
<td>( n1 -- n2) Arithmetics<br>R( -- )<br>1-complement of TOS</td>
</tr>
<tr>
<td>is</td>
<td><a href="CodeAsm/is.html#IS" title="VE_IS">IS</a></td>
<td>( xt1 c&lt;char&gt; -- ) System<br>R( --)<br>stores xt into defer or compiles code to do so at runtime</td>
</tr>
<tr>
<td>is</td>
<td><a href="CodeAsm/is.html#IS" title="VE_IS">IS</a></td>
<td>( xt1 c&lt;char&gt; -- ) System<br>R( --)<br>stores xt into defer or compiles code to do so at runtime</td>
</tr>
<tr>
<td>itype</td>
<td><a href="CodeAsm/itype.html#ITYPE" title="VE_ITYPE">ITYPE</a></td>
<td>( addr n -- ) Tools<br>R( -- )<br>reads packed string from flash and emit it</td>
</tr>
<tr>
<td>j</td>
<td><a href="CodeAsm/j.html#J" title="VE_J">J</a></td>
<td>( -- n ) Control Structure<br>R( loop-sys1 loop-sys2 -- loop-sys1 loop-sys2)<br>loop counter of outer loop</td>
</tr>
<tr>
<td>key</td>
<td><a href="CodeAsm/key.html#KEY" title="VE_KEY">KEY</a></td>
<td>( -- c ) Character IO<br>R( -- )<br>fetch key vector and execute it</td>
</tr>
<tr>
<td>key?</td>
<td><a href="CodeAsm/keyq.html#KEYQ" title="VE_KEYQ">KEYQ</a></td>
<td>( -- f) Character IO<br>R( -- )<br>fetch 'key? vector and execute it. Leave true if a character can be read, false otherwise</td>
</tr>
<tr>
<td>leave</td>
<td><a href="CodeAsm/leave.html#LEAVE" title="VE_LEAVE">LEAVE</a></td>
<td>( -- )<br>R(next limit counter -- next )<br>runtime of leave</td>
</tr>
<tr>
<td>leave</td>
<td><a href="CodeAsm/leave.html#LEAVE" title="VE_LEAVE">LEAVE</a></td>
<td>( -- )<br>R(next limit counter -- next )<br>runtime of leave</td>
</tr>
<tr>
<td>literal</td>
<td><a href="CodeAsm/literal.html#LITERAL" title="VE_LITERAL">LITERAL</a></td>
<td>( n -- ) Compiler<br>R( -- )<br>compile a literal in colon defintions</td>
</tr>
<tr>
<td>log2</td>
<td><a href="CodeAsm/log2.html#LOG2" title="VE_LOG2">LOG2</a></td>
<td>( n1 -- n2 ) Arithmetics<br>R( -- )<br>logarithm base 2 or highest set bitnumber</td>
</tr>
<tr>
<td>loop</td>
<td><a href="CodeAsm/loop.html#LOOP" title="VE_LOOP">LOOP</a></td>
<td>( addr -- ) Control Structure<br>R( -- )<br>cpmpile (loop) and resolve branch</td>
</tr>
<tr>
<td>lshift</td>
<td><a href="CodeAsm/lshift.html#LSHIFT" title="VE_LSHIFT">LSHIFT</a></td>
<td>( n1 n2 -- n3) Arithmetics<br>R( -- )<br>logical shift left</td>
</tr>
<tr>
<td>m*</td>
<td><a href="CodeAsm/mstar.html#MSTAR" title="VE_MSTAR">MSTAR</a></td>
<td>( n1 n2 -- d) Arithmetics<br>R( -- )<br>multiply 2 cells to a double cell</td>
</tr>
<tr>
<td>max</td>
<td><a href="CodeAsm/max.html#MAX" title="VE_MAX">MAX</a></td>
<td>( n1 n2 -- n1|n2 ) Compare<br>R( -- )<br>compare two values, leave the bigger one</td>
</tr>
<tr>
<td>min</td>
<td><a href="CodeAsm/min.html#MIN" title="VE_MIN">MIN</a></td>
<td>( n1 n2 -- n1|n2 ) Compare<br>R( -- )<br>compare two values leave the smaller one</td>
</tr>
<tr>
<td>mod</td>
<td><a href="CodeAsm/mod.html#MOD" title="VE_MOD">MOD</a></td>
<td>( n1 n2 -- n3) Arithmetics<br>R( -- )<br>remainder of division</td>
</tr>
<tr>
<td>negate</td>
<td><a href="CodeAsm/negate.html#NEGATE" title="VE_NEGATE">NEGATE</a></td>
<td>( n1 -- n2 ) Logic<br>R( -- )<br>2-complement</td>
</tr>
<tr>
<td>noop</td>
<td><a href="CodeAsm/noop.html#NOOP" title="VE_NOOP">NOOP</a></td>
<td>( -- ) Tools<br>R( -- )<br>do nothing</td>
</tr>
<tr>
<td>not</td>
<td><a href="CodeAsm/not.html#NOT" title="VE_NOT">NOT</a></td>
<td>( flag -- flag' ) Logic<br>R( -- )<br>identical to 0=</td>
</tr>
<tr>
<td>number</td>
<td><a href="CodeAsm/number.html#NUMBER" title="VE_NUMBER">NUMBER</a></td>
<td>(addr -- n ) Numeric IO<br>R( -- )<br>convert a word to a number, throw exception -1 on error</td>
</tr>
<tr>
<td>of</td>
<td><a href="CodeAsm/of.html#OF" title="VE_OF">OF</a></td>
<td>( -- ) Compiler<br>R( -- )<br>see case</td>
</tr>
<tr>
<td>of</td>
<td><a href="CodeAsm/of.html#OF" title="VE_OF">OF</a></td>
<td>( -- ) Compiler<br>R( -- )<br>see case</td>
</tr>
<tr>
<td>or</td>
<td><a href="CodeAsm/or.html#OR" title="VE_OR">OR</a></td>
<td>( n1 n2 -- n3 ) Logic<br>R( -- )<br>logical or</td>
</tr>
<tr>
<td>over</td>
<td><a href="CodeAsm/over.html#OVER" title="VE_OVER">OVER</a></td>
<td>( n1 n2 -- n1 n2 n1 ) Stack<br>R( -- )<br>stack manipulation</td>
</tr>
<tr>
<td>pad</td>
<td><a href="CodeAsm/pad.html#PAD" title="VE_PAD">PAD</a></td>
<td>( -- addr ) System Pointer<br>R( -- )<br>scratch buffer.</td>
</tr>
<tr>
<td>parse</td>
<td><a href="CodeAsm/parse.html#PARSE" title="VE_PARSE">PARSE</a></td>
<td>( char &quot;ccc&quot; -- c-addr u ) String<br>R( -- )<br>in input buffer parse ccc delimited string by the delimiter char.</td>
</tr>
<tr>
<td>pause</td>
<td><a href="CodeAsm/pause.html#PAUSE" title="VE_PAUSE">PAUSE</a></td>
<td>( -- ) Multitasking<br>R( -- )<br>fetch pause vector and execute it. may make a context/task switch</td>
</tr>
<tr>
<td>quit</td>
<td><a href="CodeAsm/quit.html#QUIT" title="VE_QUIT">QUIT</a></td>
<td>( -- ) System<br>R( -- )<br>main loop of amforth. accept - interpret in an endless loop</td>
</tr>
<tr>
<td>r&gt;</td>
<td><a href="CodeAsm/r_from.html#R_FROM" title="VE_R_FROM">R_FROM</a></td>
<td>( -- n ) Stack<br>R( n --)<br>move TOR to TOS</td>
</tr>
<tr>
<td>r@</td>
<td><a href="CodeAsm/r_fetch.html#R_FETCH" title="VE_R_FETCH">R_FETCH</a></td>
<td>( -- n) Stack<br>R( n -- n )<br>fetch content of TOR</td>
</tr>
<tr>
<td>recurse</td>
<td><a href="CodeAsm/recurse.html#RECURSE" title="VE_RECURSE">RECURSE</a></td>
<td>( -- ) Compiler<br>R( -- )<br>compile XT of the word beeing currently defined into dictionary (! not conforming to ANS!)</td>
</tr>
<tr>
<td>refill</td>
<td><a href="CodeAsm/refill.html#REFILL" title="VE_REFILL">REFILL</a></td>
<td>( -- f ) IO<br>R( -- )<br>refills the input buffer</td>
</tr>
<tr>
<td>repeat</td>
<td><a href="CodeAsm/repeat.html#REPEAT" title="VE_REPEAT">REPEAT</a></td>
<td>(addr1 -- addr2 ) Control Structure<br>R( -- )<br>go back to begin</td>
</tr>
<tr>
<td>rot</td>
<td><a href="CodeAsm/rot.html#ROT" title="VE_ROT">ROT</a></td>
<td>( n1 n2 n3 -- n2 n3 n1) Stack<br>R( -- )<br>stack manupulation</td>
</tr>
<tr>
<td>rp</td>
<td><a href="CodeAsm/rp0.html#RP" title="VE_RP">RP</a></td>
<td>( -- addr) Stackpointer<br>R( -- )<br>address of variable to store the return stack pointer for inactive tasks</td>
</tr>
<tr>
<td>rp!</td>
<td><a href="CodeAsm/rpstore.html#RP_STORE" title="VE_RP_STORE">RP_STORE</a></td>
<td>( n -- ) Stackpointer<br>R( -- xy)<br>set return stack pointer</td>
</tr>
<tr>
<td>rp0</td>
<td><a href="CodeAsm/rp0.html#RP0" title="VE_RP0">RP0</a></td>
<td>( -- addr) Stackpointer<br>R( -- )<br>start value of return stack</td>
</tr>
<tr>
<td>rp@</td>
<td><a href="CodeAsm/rpfetch.html#RP_FETCH" title="VE_RP_FETCH">RP_FETCH</a></td>
<td>( -- n) Stackpointer<br>R( -- )<br>current return stack pointer address</td>
</tr>
<tr>
<td>rshift</td>
<td><a href="CodeAsm/rshift.html#RSHIFT" title="VE_RSHIFT">RSHIFT</a></td>
<td>( n1 n2 -- n3 ) Arithmetics<br>R( -- )<br>logical shift right</td>
</tr>
<tr>
<td>rx0</td>
<td><a href="CodeAsm/usart.html#RX0" title="VE_RX0">RX0</a></td>
<td>( -- c) Hardware Access<br>R( --)<br>get 1 character from input queue, wait if needed</td>
</tr>
<tr>
<td>rx0?</td>
<td><a href="CodeAsm/usart.html#RX0Q" title="VE_RX0Q">RX0Q</a></td>
<td>( -- f) Hardware Access<br>R( --)<br>check if unread characters are in the input queue.</td>
</tr>
<tr>
<td>s&quot;</td>
<td><a href="CodeAsm/squote.html#SQUOTE" title="VE_SQUOTE">SQUOTE</a></td>
<td>( &lt;cchar&gt; -- ) Compiler<br>R( -- )<br>compiles a string to flash, at runtime leaves ( -- addr count) on stack</td>
</tr>
<tr>
<td>s&quot;</td>
<td><a href="CodeAsm/squote.html#SQUOTE" title="VE_SQUOTE">SQUOTE</a></td>
<td>( &lt;cchar&gt; -- ) Compiler<br>R( -- )<br>compiles a string to flash, at runtime leaves ( -- addr count) on stack</td>
</tr>
<tr>
<td>s,</td>
<td><a href="CodeAsm/scomma.html#SCOMMA" title="VE_SCOMMA">SCOMMA</a></td>
<td>( addr len -- ) Compiler<br>R( -- )<br>compiles a string from RAM to Flash</td>
</tr>
<tr>
<td>s&gt;d</td>
<td><a href="CodeAsm/s_to_d.html#S2D" title="VE_S2D">S2D</a></td>
<td>( n1 -- d1 ) Conversion<br>R( -- )<br>extend (signed) single cell value to double cell</td>
</tr>
<tr>
<td>sign</td>
<td><a href="CodeAsm/sign.html#SIGN" title="VE_SIGN">SIGN</a></td>
<td>( n -- ) Numeric IO<br>R( -- )<br>place a - in HLD if value is negative</td>
</tr>
<tr>
<td>sleep</td>
<td><a href="CodeAsm/sleep.html#SLEEP" title="VE_SLEEP">SLEEP</a></td>
<td>( -- ) Interrupt<br>R( -- )<br>calls the MCU sleep instruction. Not useful itself!</td>
</tr>
<tr>
<td>source</td>
<td><a href="CodeAsm/source.html#SOURCE" title="VE_SOURCE">SOURCE</a></td>
<td>( addr1 u1 n-- addr2 u2 ) System<br>R( -- )<br>adjust string from addr1 to addr1+n, reduce length from u1 to u2</td>
</tr>
<tr>
<td>sp</td>
<td><a href="CodeAsm/sp0.html#SP" title="VE_SP">SP</a></td>
<td>( -- addr) Stackpointer<br>R( -- )<br>address of variable to store data stack pointer for inactive tasks</td>
</tr>
<tr>
<td>sp!</td>
<td><a href="CodeAsm/spstore.html#SP_STORE" title="VE_SP_STORE">SP_STORE</a></td>
<td>( addr -- i*x) Stackpointer<br>R( -- )<br>data stack pointer changed to addr</td>
</tr>
<tr>
<td>sp0</td>
<td><a href="CodeAsm/sp0.html#SP0" title="VE_SP0">SP0</a></td>
<td>( -- addr) Stackpointer<br>R( -- )<br>start of data stack</td>
</tr>
<tr>
<td>sp@</td>
<td><a href="CodeAsm/spfetch.html#SP_FETCH" title="VE_SP_FETCH">SP_FETCH</a></td>
<td>( -- n) Stackpointer<br>R( -- )<br>current data stack pointer</td>
</tr>
<tr>
<td>space</td>
<td><a href="CodeAsm/space.html#SPACE" title="VE_SPACE">SPACE</a></td>
<td>( -- ) Character IO<br>R( -- )<br>emits a space (bl)</td>
</tr>
<tr>
<td>state</td>
<td><a href="CodeAsm/state.html#STATE" title="VE_STATE">STATE</a></td>
<td>( -- addr ) Compiler<br>R( -- )<br>system state</td>
</tr>
<tr>
<td>swap</td>
<td><a href="CodeAsm/swap.html#SWAP" title="VE_SWAP">SWAP</a></td>
<td>( n1 n2 -- n2 n1) Stack<br>R( -- )<br>stack manipulation</td>
</tr>
<tr>
<td>then</td>
<td><a href="CodeAsm/then.html#THEN" title="VE_THEN">THEN</a></td>
<td>( addr -- ) Compiler<br>R( -- )<br>finish if</td>
</tr>
<tr>
<td>throw</td>
<td><a href="CodeAsm/throw.html#THROW" title="VE_THROW">THROW</a></td>
<td>( n -- ) Exceptions<br>R( -- )<br>throw an exception</td>
</tr>
<tr>
<td>tib</td>
<td><a href="CodeAsm/tib.html#TIB" title="VE_TIB">TIB</a></td>
<td>( -- addr ) System Pointer<br>R( -- )<br>terminal input buffer address</td>
</tr>
<tr>
<td>to</td>
<td><a href="CodeAsm/to.html#TO" title="VE_TO">TO</a></td>
<td>( n &lt;name&gt; -- ) Tools<br>R( --)<br>store the TOS to value (an EEPROM 16bit cell)</td>
</tr>
<tr>
<td>turnkey</td>
<td><a href="CodeAsm/turnkey.html#TURNKEY" title="VE_TURNKEY">TURNKEY</a></td>
<td>( -- eaddr) System Pointer<br>R( -- )<br>address of the variable that holds an XT to be started by cold before quit takes over</td>
</tr>
<tr>
<td>tx0</td>
<td><a href="CodeAsm/usart.html#TX0" title="VE_TX0">TX0</a></td>
<td>(c -- ) Hardware Access<br>R( --)<br>put 1 character into output queue, wait if needed, enable UDRIE0 interrupt</td>
</tr>
<tr>
<td>tx0?</td>
<td><a href="CodeAsm/usart.html#TX0Q" title="VE_TX0Q">TX0Q</a></td>
<td>( -- f) Hardware Access<br>R( --)<br>check if a character can be appended to output queue.</td>
</tr>
<tr>
<td>type</td>
<td><a href="CodeAsm/type.html#TYPE" title="VE_TYPE">TYPE</a></td>
<td>( addr n -- ) Character IO<br>R( -- )<br>emits a string</td>
</tr>
<tr>
<td>u*/mod</td>
<td><a href="CodeAsm/ustarslashmod.html#USTARSLASHMOD" title="VE_USTARSLASHMOD">USTARSLASHMOD</a></td>
<td>( u1 u2 u3 -- rem quot) Arithmetics<br>R( -- )<br>unsigned division with remainder u3 * u2 / u1</td>
</tr>
<tr>
<td>u.</td>
<td><a href="CodeAsm/udot.html#UDOT" title="VE_UDOT">UDOT</a></td>
<td>( n -- ) Numeric IO<br>R( -- )<br>unsigned numeric output</td>
</tr>
<tr>
<td>u.</td>
<td><a href="CodeAsm/udot.html#UDOT" title="VE_UDOT">UDOT</a></td>
<td>( n -- ) Numeric IO<br>R( -- )<br>unsigned numeric output</td>
</tr>
<tr>
<td>u/mod</td>
<td><a href="CodeAsm/uslashmod.html#USLASHMOD" title="VE_USLASHMOD">USLASHMOD</a></td>
<td>(u1 u2 -- rem quot) Arithmetics<br>R( -- )<br>unsigned division with remainder</td>
</tr>
<tr>
<td>u&lt;</td>
<td><a href="CodeAsm/uless.html#ULESS" title="VE_ULESS">ULESS</a></td>
<td>( u1 u2 -- flasg) Compare<br>R( -- )<br>compare values u1 &lt; u2 (unsigned)</td>
</tr>
<tr>
<td>u&gt;</td>
<td><a href="CodeAsm/ugreater.html#UGREATER" title="VE_UGREATER">UGREATER</a></td>
<td>( u1 u2 -- flag ) Compare<br>R( -- )<br>compares u1 &gt; u2 (unsigned)</td>
</tr>
<tr>
<td>um/mod</td>
<td><a href="CodeAsm/umslashmod.html#UMSLASHMOD" title="VE_UMSLASHMOD">UMSLASHMOD</a></td>
<td>( ud u2 -- rem quot) Arithmetics<br>R( -- )<br>unsigned division ud / u2 with remainder</td>
</tr>
<tr>
<td>unloop</td>
<td><a href="CodeAsm/unloop.html#UNLOOP" title="VE_UNLOOP">UNLOOP</a></td>
<td>( -- ) Control Structure<br>R(loop-sys -- )<br>remove loop-sys</td>
</tr>
<tr>
<td>until</td>
<td><a href="CodeAsm/until.html#UNTIL" title="VE_UNTIL">UNTIL</a></td>
<td>( addr -- ) Compiler<br>R( -- )<br>finish begin with conditional branch</td>
</tr>
<tr>
<td>unused</td>
<td><a href="CodeAsm/unused.html#UNUSED" title="VE_UNUSED">UNUSED</a></td>
<td>( -- n ) Tools<br>R( -- )<br>number of unused flash cells</td>
</tr>
<tr>
<td>up!</td>
<td><a href="CodeAsm/up.html#UP_STORE" title="VE_UP_STORE">UP_STORE</a></td>
<td>( addr -- ) System<br>R( -- )<br>set user pointer</td>
</tr>
<tr>
<td>up@</td>
<td><a href="CodeAsm/up.html#UP_FETCH" title="VE_UP_FETCH">UP_FETCH</a></td>
<td>( -- addr ) System<br>R( -- )<br>get user pointer</td>
</tr>
<tr>
<td>usart0</td>
<td><a href="CodeAsm/usart.html#USART0" title="VE_USART0">USART0</a></td>
<td>( -- ) Hardware Access<br>R( --)<br>initialize usart0</td>
</tr>
<tr>
<td>user</td>
<td><a href="CodeAsm/user.html#USER" title="VE_USER">USER</a></td>
<td>( n -- ) Compiler<br>R( -- )<br>define a new user variable</td>
</tr>
<tr>
<td>value</td>
<td><a href="CodeAsm/value.html#VALUE" title="VE_VALUE">VALUE</a></td>
<td>( n &lt;name&gt; -- ) Compiler<br>R( -- )<br>allocate space for 1 cell in EEPROM. used in conjunction with TO</td>
</tr>
<tr>
<td>variable</td>
<td><a href="CodeAsm/variable.html#VARIABLE" title="VE_VARIABLE">VARIABLE</a></td>
<td>( -- ) Compiler<br>R( -- )<br>create a variable entry and allocate RAM space for it</td>
</tr>
<tr>
<td>ver</td>
<td><a href="CodeAsm/ver.html#VER" title="VE_VER">VER</a></td>
<td>( -- ) Tools<br>R( -- )<br>emits the version string</td>
</tr>
<tr>
<td>wdr</td>
<td><a href="CodeAsm/wdr.html#WDR" title="VE_WDR">WDR</a></td>
<td>( -- ) Interrupt<br>R( -- )<br>calls the MCU wdr instruction</td>
</tr>
<tr>
<td>while</td>
<td><a href="CodeAsm/while.html#WHILE" title="VE_WHILE">WHILE</a></td>
<td>( dest -- orig dest ) Control Structure<br>R( -- )<br>control structure</td>
</tr>
<tr>
<td>word</td>
<td><a href="CodeAsm/word.html#WORD" title="VE_WORD">WORD</a></td>
<td>( c -- addr ) Tools<br>R( -- )<br>skip leading delimiter characters and parses TIB to the next delimiter. copy the word into PAD</td>
</tr>
<tr>
<td>words</td>
<td><a href="CodeAsm/words.html#WORDS" title="VE_WORDS">WORDS</a></td>
<td>( -- ) Tools<br>R( -- )<br>emits a list of all (visible) words in the dictionary</td>
</tr>
<tr>
<td>words</td>
<td><a href="CodeAsm/words.html#WORDS" title="VE_WORDS">WORDS</a></td>
<td>( -- ) Tools<br>R( -- )<br>emits a list of all (visible) words in the dictionary</td>
</tr>
<tr>
<td>xor</td>
<td><a href="CodeAsm/xor.html#XOR" title="VE_XOR">XOR</a></td>
<td>( n1 n2 -- n3) Logic<br>R( -- )<br>exclusive or</td>
</tr>
</table>
 
</div>
 
<!-- AUTOINCLUDE START "Page/Footer.en.ihtml" DO NOT REMOVE -->
<!-- ============== FOOTER ============== -->
<div class="Footer">
<script type="text/javascript">
<!--
SetRelativePath("../../../");
DrawFooter();
// -->
</script>
<noscript>
<p><b> JavaScript is required for including of the footer </b></p>
</noscript>
</div>
<!-- AUTOINCLUDE END -->
 
</body>
</html>