トップ差分一覧ソース検索ヘルプ RSS ログイン

make port=/dev/ttyUSB0 flash

Arduino IDE CORE

/* Forth サンプル */
/* オリジナルは以下のところ 
* http://phaendal.hatenablog.com/entry/2015/07/29/091821
* https://github.com/phaendal/documentation- forth/tree/master/006.interactive_rstack_recur/c-sample 
*/
/* 変更内容
 * STM32duino 用に書き換え
 /*
// #define DICT_MAX 65535
// #define DICT_MAX 2048  # STM32F103C6 MAX 
#define DICT_MAX 1024
// #define DICT_MAX 192
// #define DICT_MAX 180

//******************************************************
//#include <avr/pgmspace.h>
//******************************************************
// typedef long int Number;
// typedef int Number;
typedef long Number;
typedef char* FString;

// Core
typedef void (*Core)(void);

// ワードのフラグ
typedef struct  {
 unsigned int immediate:1;
 unsigned int hidden:1;
} wflag;

// Header
typedef struct {
 int    next;
 char  *hname;
 wflag *flag;
} Header ;

typedef union {
 Number number;
 FString str;
 Core   core;
 Header *header;
} DictValue;

// スタック
//=================================================================================================
DictValue dstack[128] ;
// DictValue dstack[64] ;
// DictValue dstack[32] ;
//****************************************************************************************************
long int doToken (char);
void procValue (DictValue);


//=================================================================================================
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <stdarg.h>
// =================================================================================================


static int dsp = 0;

// int rstack[128];
// static int rstack[64];
// static int rstack[32];
static int rstack[128];
static int rsp = 0;

void rpush (int x) {
 rstack[rsp] = x;
 rsp++;
}

int rpop () {
 rsp--;
 return rstack[rsp];
}

void dpush (DictValue x) {
 dstack[dsp] = x;
 dsp++;
}

DictValue dpop () {
 if ( dsp <= 0 ) {
   Serial.print("Stuck underflow");
    return dstack[dsp];
 }
 dsp--;
 return dstack[dsp];
}


// 辞書とVM
// =================================================================================================
DictValue ip;
int np;

// #define DICT_MAX 65536
// 終了用の番兵
static DictValue dict[DICT_MAX] = { 0 } ; 
// 終了用の番兵

int latest = 0;
int dict_here = 1;

void pushDict(DictValue v) {
 dict[dict_here] = v;
 dict_here++;
}

// to Core Field Address
int toCFA (int addr) {
 return addr + 1;
}

// フラグのチェックと操作
int isHidden (wflag *flag) {
 // hiddenなら0を返す
 return flag->hidden;
}

int isImmediate (wflag *flag) {
 return flag->immediate;
}

void toggleHidden (wflag *flag) {
 flag->hidden = !flag->hidden;
}

void setImmediate (int addr, int flag) {
 Header *word = dict[addr].header;
 word->flag->immediate = flag;
}


// NEXTルーチン
// =================================================================================================
void next () {
 ip = dict[np];
 np++;
}

void docolon () {
 rpush(np);
 np = ip.number + 1;
 next();
}

void execute () {
 while (ip.number != 0) {
   dict[ip.number].core();
 }
}


// ワード定義関数
// ==================================================================================== =============
int createHeader (char *hname) {
 // ヘッダを作り、そのヘッダのアドレスを返す
 // Header *h = malloc(sizeof(Header));
 Header *h = new(Header);
 // wflag *flag = malloc(sizeof(wflag));
 wflag *flag = new(wflag);
 flag->immediate = 0;
 flag->hidden    = 0;

 DictValue d;
 h->next = latest;
 h->hname = strdup(hname);
 h->flag = flag;

 latest = dict_here;
 d.header = h;
 pushDict(d);

 return latest;
}

void freeHeader (Header *h) {
 free(h->hname);
 free(h->flag);
 free(h);
}

int defnative (char *cname, Core core) {
 // Coreのみのネイティブワードを作り、そのアドレスを返す
 int addr = createHeader(cname);

 DictValue d = {.core = core};
 pushDict(d);
 return addr;
}

int defword (char *name, ...) {
 // 可変長引数の準備
 va_list ap;
 va_start(ap, name);

 // コロンワードを作り、そのアドレスを返す
 // dfは0で終わっている必要がある
 int addr = createHeader(name);

 DictValue d = {.core = docolon};
 pushDict(d);

 int word = va_arg(ap, int);
 for (; word != 0; word = va_arg(ap, int)) {
   int cfa = toCFA(word);
   DictValue n = {.number = cfa};
   pushDict(n);
 }

 va_end(ap);

 return addr;
} 


// 組み込みワード用Core
// 
==================================================================================== =============
void pushTwo () {
 DictValue two = {.number = 2};
 dpush(two);
 next();
}

void mul () {
 Number a = dpop().number;
 Number b = dpop().number;
 DictValue x = {.number = a * b};
 dpush(x);
 next();
}

void add () {
 Number a = dpop().number;
 Number b = dpop().number;
 DictValue x = {.number = a + b};
 dpush(x);
 next();
}

void sub () {
 Number b = dpop().number;
 Number a = dpop().number;
 DictValue x = {.number = a - b};
 dpush(x);
 next();
}


// Stack Operation

void w_swap () {
 DictValue a = dpop();
 DictValue b = dpop();
 dpush(a);
 dpush(b);
 next();
}

void w_dup () {
 DictValue x = dpop();
 dpush(x);
 dpush(x);
 next();
}

void w_drop () {
 dpop();
 next();
}


// リターンスタック

void w_rpush () {
 rpush(dpop().number);
 next();
}

void w_rpop () {
 DictValue x;
 x.number = rpop();
 dpush(x);
 next();
}


void printStackItem () {
 // printf("%d ", dpop().number);
 // Serial.print("TTTTTTT");
 Serial.print(dpop().number);
 next();
}

void printStack () {
 Serial.print(dsp);
 int i;
 for (i = 0; i < dsp; i++) {
   Serial.print(dstack[i].number);
 }
 next();
}

void ret () {
 np = rpop();
 next();
}


// vm-mode
// -------------------------------------------------------------------------------------------------
// int vm_mode = 0; // 0: execute, 1: compile
byte vm_mode = 0; // 0: execute, 1: compile

void executeMode () {
 vm_mode = 0;
} 

void w_execute_mode () {
 executeMode();
 next();
}

void compileMode () {
 vm_mode = 1;
}

void w_compile_mode () {
 compileMode();
 next();
}


// read-token>
// -------------------------------------------------------------------------------------------------
// 前方宣言
char* readToken ();

// #define TOKEN_BUFFER_SIZE 16
// #define MAX_TOKEN_LEN 128
#define TOKEN_BUFFER_SIZE 16
#define MAX_TOKEN_LEN 32

char token_buffer[TOKEN_BUFFER_SIZE][MAX_TOKEN_LEN];

int tokenBufPos () {
 // Returns token buffer position(r) and increment cycle counter(i)
 // static i = 0;
 static int i = 0;
 int r = i;

 i = (i + 1) % TOKEN_BUFFER_SIZE;
 return r;
}

char* bufferToken (char* token) {
 int pos = tokenBufPos();
 strcpy(token_buffer[pos], token);
 return token_buffer[pos];
}

void w_read_token () {
 char *token = bufferToken(readToken());
 DictValue s = {.str = token};
 dpush(s);
 next();
}

void printStr () {
 Serial.print(dpop().str);   // printf("str\n")
 Serial.print(F("\n"));
 next();
}

// 辞書操作

void w_create_header () {
 DictValue d = dpop();
 createHeader(d.str);

 // コロンワード用にdocolを置く
 DictValue docol = {.core = docolon};
 pushDict(docol);

 next();
}

void w_toggle_hidden () {
 // latestワードのhiddenフラグを切り替える
 Header *h = dict[latest].header;
 wflag *flag = h->flag;
 toggleHidden(flag);
 next();
}

void w_fetch_dict_here () {
 DictValue x = {.number = dict_here};
 dpush(x);
 next();
}

void w_set_dict_here () {
 dict_here = dpop().number;
 next();
}

void w_latest () {
 DictValue x = {.number = latest};
 dpush(x);
 next();
}

void w_store_latest () {
 latest = dpop().number;
 next();
}

void lit () {
 // lit x という順番で辞書に追加されているxを、データスタックに置く。
 // 今、npがxが入ってるアドレスを指しているので、取り出してスタックに置き、
 // その分npを進める。
 dpush(dict[np]);
 np++;
 next();
}

void w_push_dict () {
 DictValue d = dpop();
 pushDict(d);
 next();
}

void w_immediate () {
 setImmediate(latest, 1);
 next();
}

// メモリ操作

void w_mem_fetch () {
 DictValue d = dpop();
 dpush(dict[d.number]);
 next();
}

void w_mem_set () {
 DictValue a = dpop();
 DictValue v = dpop();
 dict[a.number] = v;
 next();
}

// branch

void w_branch () {
 DictValue offset = dict[np];
 np += offset.number;
 next();
}

void w_0branch () {
 Number x = dpop().number;

 if (x != 0) {
   np++;
   next();
   return;
 }

 w_branch();
}

// find, >cfa

int findWord (char *token, int addr) {
 Header *word;

 while (addr != 0) {
   word = dict[addr].header;

   if (!isHidden(word->flag) != 0 && strcmp(token, word->hname) == 0) {
     return addr;
   }

   addr = word->next;
 }

 return 0;
}

void w_find () {
 DictValue x = dpop();
 int addr = findWord(x.str, latest);
 DictValue a = {.number = addr};
 dpush(a);
 next();
}

void w_tcfa () {
 DictValue x = dpop();
 DictValue a = {.number = toCFA(x.number)};
 dpush(a);
 next();
}

// 比較
#define BINCOMP(NAME,OP)       \
void NAME () {                 \
 DictValue b = dpop();        \
 DictValue a = dpop();        \
 DictValue r = {.number = 0}; \
 if (a.number OP b.number) {  \
   r.number = 1;              \
 }                            \
 dpush(r);                    \
 next();                      \
}

BINCOMP(w_lt,  <);
BINCOMP(w_gt,  >);
BINCOMP(w_le,  <=);
BINCOMP(w_ge,  >=);
BINCOMP(w_eq,  ==);
BINCOMP(w_neq, !=);

void w_bye () {
 exit(0);
}

// コンパイル時などに使用するワード
int word_lit;

//+++++++++++++++++++++++++++++++++++++++++++++++++++++
void prepareBuiltins () {
 
 int word_2   = defnative((char *)F("2"), pushTwo);
 int word_mul = defnative((char *)F("*"), mul);
 int word_add = defnative((char *)F("+"), add);
   
 int word_sub = defnative((char *)F("-"), sub);
 
 int word_swap = defnative((char *)F("swap"), w_swap);
 int word_dup  = defnative((char *)F("dup"),  w_dup);
 int word_drop = defnative((char *)F("drop"), w_drop);
   
 int word_rpush = defnative((char *)F(">r"), w_rpush);
 int word_rpop  = defnative((char *)F("r>"), w_rpop);
 
 int word_find = defnative((char *)F("find"), w_find);
 int word_tcfa = defnative((char *)F(">cfa"), w_tcfa);
  
 int word_dot  = defnative((char *)F("."),  printStackItem);
 int word_print_str  = defnative((char *)F("print"), printStr);
 int word_dots = defnative((char *)F(".s"), printStack);
 
 int word_ret = defnative((char *)F("ret"), ret);

 int word_read_token = defnative((char *)F("read-token>"), w_read_token);

 int word_execute_mode = defnative((char *)F("execute-mode>>"), w_execute_mode);
     setImmediate(word_execute_mode, 1);

 int word_compile_mode = defnative((char *)F("compile-mode>>"), w_compile_mode);

 int word_create_header = defnative((char *)F("create-header"), w_create_header);
 int word_toggle_hidden = defnative((char *)F("toggle-hidden"), w_toggle_hidden);

 int word_fetch_dict_here = defnative((char *)F("dict-here"), w_fetch_dict_here);
 int word_set_dict_here   = defnative((char *)F("dict-here!"), w_set_dict_here);
 
 int word_latest = defnative((char *)F("latest"), w_latest);
 int word_store_latest = defnative((char *)F("latest!"), w_store_latest);
 
 word_lit = defnative((char *)F("lit"), lit);
 int word_push_dict = defnative((char *)F("push-dict"), w_push_dict);

 int word_mem_fetch = defnative((char *)F("@"), w_mem_fetch);
 int word_mem_set   = defnative((char *)F("!"), w_mem_set);

 int word_branch  = defnative((char *)F("branch"), w_branch);
 int word_0branch = defnative((char *)F("0branch"), w_0branch);
  
 int word_immediate = defnative((char *)F("immediate!"), w_immediate);
  
 // 比較
 int word_gt  = defnative((char *)F(">"),  w_gt);
 int word_lt  = defnative((char *)F("<"),  w_lt);
 int word_ge  = defnative((char *)F(">="), w_ge);
 int word_le  = defnative((char *)F("<="), w_le);
 int word_equ = defnative((char *)F("="),  w_eq);
 int word_neq = defnative((char *)F("<>"), w_neq);
 
 // defwordの引数は0で終わること
 int word_2x   = defword((char *)F("2*"), word_2, word_mul, word_ret, 0);
 int word_4x   = defword((char *)F("4*"), word_2x, word_2x, word_ret, 0);
 int word_16x  = defword((char *)F("16*"), word_4x, word_4x, word_ret, 0);
 int word_main = defword((char *)F("main"), word_2, word_16x, word_dot, word_ret, 0);

 int word_colon = defword((char *)F(":"),
           word_read_token, word_create_header,
           word_toggle_hidden, word_compile_mode, word_ret, 0);

 int word_semicolon =
   defword((char *)F(";"),
           word_lit, word_ret, word_push_dict,
           word_toggle_hidden, word_execute_mode, word_ret, 0);
   setImmediate(word_semicolon, 1);

 int word_bye = defnative((char *)F("bye"), w_bye);
 // defnative((char *)F("bye"), w_bye);
}

// interpret
//=================================================================================================
// Reader
// -------------------------------------------------------------------------------------------------
#define READER_BUFFER_SIZE 256
// #define READER_BUFFER_SIZE 128

char rbuffer[READER_BUFFER_SIZE];
char token[READER_BUFFER_SIZE];
int  rpos = 0;
//byte  rpos = 0;

void setupReader (char *cstr) {
 memset(rbuffer, 0, READER_BUFFER_SIZE);
 strcpy(rbuffer, cstr);
 rpos = 0;
}

char reader () {
 // 呼ばれる度に入力を1文字消費して返す
 rpos++;
 return rbuffer[rpos - 1];
}

int isDelimiter (char c) {
 return (c == ' '  ||
         c == '\n' ||
         c == '\0');
}

char skipSpace () {
 // 空白と改行を読み飛ばし続け、空白以外の文字が来たらそれを返す。
 // 入力が尽きたら0を返す(NULL文字)
 char c = reader();
 // Serial.print(c); // GREEN TEST
 // Serial.print(isDelimiter(c));
 while (c != 0 && isDelimiter(c)) {
   c = reader();
 }
 // Serial.print(c); // GREEN TEST
 return c;
}

char* readToken () {
 // トークンをバッファから切り出して、グローバル変数tokenに入れてそのアドレスを返す
 // 入力が尽きていた場合はNULLを返す
 int  pos = 0;
 char c = skipSpace();
 // Serial.print(c); // GREEN TEST
  
 // 入力が尽きていた
 if (c == '\0') { return NULL; }

 // Serial.print(pos);  // GREEN TEST
 token[pos] = c;

 while (!isDelimiter(c)) {
   pos++;
   c = reader();
   token[pos] = c;
 }

 // NULL終端
 token[pos] = 0;

 Serial.print(token); // GREEN TEST
 return token;
}

// ワードの実行、又はリテラルとして解釈
// --------------------------------------------------------------------------------- ----------------
void executeCFA (int cfa) {
 ip.number = cfa;
 np = 0;
 execute();
}

void procWord (int addr) {
 int cfa = toCFA(addr);
   
Header *word = dict[addr].header;
 
 if (vm_mode == 0 || isImmediate(word->flag)) {
   executeCFA(cfa);
   return;
 }

 // コンパイル
 DictValue d = {.number = cfa};
 pushDict(d);
}

DictValue asValue (char *token, char **check) {
 // トークンを値(リテラル)として解釈し、その値を返す
 // 解釈に成功したら、checkにNULLをセットする。
 Number x = strtol(token, check, 10);
 DictValue d = {.number = x};
 return d;
}

void procValue (DictValue value) {
 if (vm_mode == 0) {
   dpush(value);
   return;
 }

 // コンパイル
 DictValue wlit = {.number = toCFA(word_lit)};
 pushDict(wlit);
 pushDict(value);
}

long int doToken (char *token) {
 // トークンを解釈し実行する。
 // 解釈できれば0、できなければ-1を返す。
 
 // DictValue dvalue ;
 int addr  = findWord(token, latest) ;
 char  *check = NULL ;
    
 // ワードが見つかった場合
 if (addr != 0) {
   procWord(addr);
   return 0;
 }

 // 数字として解釈出来た場合
  DictValue dvalue = asValue(token, &check);
 if (*check == '\0') {
   procValue(dvalue);
   return 0;
 }

 // エラー
 Serial.print(F("Word not found::"));
 Serial.print(token);
 Serial.print("::\n");
 // printf("Word not found: %s\n", token);
 return -1;
}

// コード実行
// -------------------------------------------------------------------------------------------------
void interpret (char *code) {
 // Serial.print("GREEN_TEST::");
 // Serial.print(code);  // GREEN.TEST
 // Serial.print("::GREEN_TEST\n");
 setupReader(code);
 // Serial.print(code);   // GreenTEST
 char *token = readToken();
 int succeeded = 0;

 while (token != NULL && succeeded == 0) {
   succeeded = doToken(token);
   token = readToken();
 }
}

// コマンドライン
// -------------------------------------------------------------------------------------------------
void repl () {
 // char buff[64]; //READER_BUFFER_SIZE
 char buff[READER_BUFFER_SIZE];
 // char buff[255];
 int cnt = 0;
 boolean ready = false;
 // ORIGN linux program
 // while (fgets(buff, 255, stdin)) {
 //   interpret(buff);
 // }
 while( true ) {
   if (ready)
    {
       // Serial.print("GREEN_TEST::");
       // Serial.print(buff);  // GREEN.TEST
       // Serial.print("::GREEN_TEST\n");
       interpret(buff);
       ready = false;
    } else while (Serial.available()) {
      char c = Serial.read();
       buff[cnt++] = c;
       if ((c == '\n') || (cnt == sizeof(buff)-1))
       {
           buff[cnt] = '\0';
           cnt = 0;
           ready = true;
       }
  }  }
}

/***********************************************/

void loop() {
 // put your main code here, to run repeatedly:

 //  int main (int argc, char* argv[]) {
 prepareBuiltins();

 // // if
 interpret((char *)F(": 'lit lit lit push-dict ;"));
 interpret((char *)F(": 'push-dict lit push-dict push-dict ;"));
 interpret((char *)F(": compile> 'lit read-token> find >cfa push-dict 'push-dict ; immediate!"));
 // 
 interpret((char *)F(": if compile> 0branch dict-here 0 push-dict ; immediate!"));
 interpret((char *)F(": save-offset dup dict-here swap - swap ! ;"));
 interpret((char *)F(": then save-offset ; immediate!"));
 interpret((char *)F(": save-else-offset swap save-offset ;"));
 interpret((char *)F(": else compile> branch dict-here 0 push-dict save-else-offset ; immediate!"));
 //
 // // ループ
 // // begin ... until
 interpret((char *)F(": begin dict-here ; immediate!"));
 interpret((char *)F(": until compile> 0branch dict-here - push-dict ; immediate!"));
 //
 // // begin .. again
 interpret((char *)F(": 'back-branch compile> branch dict-here - push-dict ;"));
 interpret((char *)F(": again 'back-branch ; immediate!"));
 // 
 // // begin ... while ... repeat
 interpret((char *)F(": while compile> 0branch dict-here 0 push-dict ; immediate!"));
 interpret((char *)F(": repeat  swap 'back-branch  save-offset ; immediate!"));
 // 
 interpret((char *)F(": recur latest >cfa push-dict ; immediate!"));
 // 
 //
 Serial.print("TEST command ");
 interpret((char *)F(": testcmd 1 2 + . ; immediate!"));
 interpret((char *)F(" testcmd "));
 //
 repl();
 //
 Serial.println("EXIT");
 return ;
}
 
//***************************
//***************************
void setup() {
 // put your setup code here, to run once:
 // Serial.begin(9600); 
 //******************************
 pinMode(33, OUTPUT);
 Serial.begin();  // USB does not require BAUD
 // wait for serial monitor to be connected.
 while (!Serial)
 {
   digitalWrite(33,!digitalRead(33));// Turn the LED from off to on, or on to off
   delay(100);         // fast blink
 }
 //******************************
 Serial.println("YunoyamaFORTH");
 Serial.println("0.00");
}
//***************************

PRG-stm32-forth

CFOTH

with WROOM32/ESP32

Arduino IDE CORE

メニュー

SYSTEM_HowTo

Linuxのメモランダム

FreeBSDのメモランダム

林檎と悪魔とペンギンと

計算

工作

最近(５日間)の更新