camelforth-a.ino

diagram.json

#include <Arduino.h>

#ifdef __cplusplus
extern "C" {
#endif

// void experiment_a_asm(unsigned int *rptr);

// extern void this_here();

void this_here();
void interpreter(void);

/*
char getch(void);
void putch(char c);
int getquery(void);
*/


extern void this_here_now();

char getch(void) {
//  this_here_now();
    bool waiting_ch = 0;

    for (int testing = 5; testing > 0; testing--) {
      ;
    }

    while (!waiting_ch) {
      waiting_ch = Serial.available();
      // this_here_now(); // loop
    }

    if (waiting_ch) {
      char ch = Serial.read();
      return ch;
    }
}

void putch(char c) {
    printf("%c", c);

    return ;  // doesn't have to do anything
}


int getquery(void) {
    // return(UARTCharsAvail(UART0_BASE) != 0);
    return(0 != 0);
}






#ifdef __cplusplus
}
#endif



void trapped() {
  // this_here_now();
  // this_here_now();

  interpreter();

  while(-1);
}

void setup() {
  Serial.begin(9600);
  Serial.write(' ');
  Serial.println("\n\n Camelforth in C");
  pinMode(15, OUTPUT);

/*
  for (int count = 3; count > 0; count--) {
    digitalWrite(15, 1);
    delay(90);
    digitalWrite(15, 0);
    delay(700);
  }
*/

  // this_here_now();

  // pinMode(LED_BUILTIN, OUTPUT);

  trapped();
}

void loop() {
  ;
}

// END.


n_sk_camelforth.cpp

forth.c

/****h* camelforth/forth.h
 * NAME
 *  forth.h
 * DESCRIPTION
 *  Header file for forth.c
 ******
 * LICENSE TERMS
 *  CamelForth in C 
 *  copyright (c) 2016,2017 Bradford J. Rodriguez.
 *  
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *  
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *  
 *  Commercial inquiries should be directed to the author at 
 *  115 First St., #105, Collingwood, Ontario L9Y 4W3 Canada
 *  or via email to bj@camelforth.com
 */

/*
 * CONFIGURATION FLAGS
 */

// #define INTERPRETER_ONLY       /* to omit Forth compiler words */

/* define only one of the following */
// 2 July 2023 was enabled define LINUX
// #define LINUX                   /* for development under Linux */
// #define TIVA_C                 /* for use with TI TM4C12x */

/* 
 * CONFIGURATION PARAMETERS
 */

#define CELL 4              /* CPU dependency, # of bytes/cell */
#define CELLWIDTH 32        /* # of bits/cell */
#define CELLMASK 0xffffffff /* mask for CELLWIDTH bits */

#define PSTACKSIZE 64       /* 64 cells */
#define RSTACKSIZE 64       /* 64 cells */
#define LSTACKSIZE 32       /* 32 cells */
#define USERSIZE   32       /* 32 cells */
#define TIBSIZE    84       /* 84 characters */
#define PADSIZE    84       /* 84 characters */
#define HOLDSIZE   34       /* 34 characters */

/*
 * DATA STRUCTURES
 */

#ifdef TIVA_C       /* why won't TI compiler handle variable string? */
struct Header {
    void * link;            /* pointer to previous header */
    void * cfa;             /* pointer to high level def'n */
    unsigned char flags;    /* immed flag and others */
    char nfa[13];           /* inline name string */
};
#else
struct Header {
    void * link;            /* pointer to previous header */
    void * cfa;             /* pointer to high level def'n */
    unsigned char flags;    /* immed flag and others */
    char nfa[];             /* inline name string */
};
#endif
 
#define HEADER(name,prev,flags,namestring) const struct Header H##name =\
    { (char *)H##prev.nfa, T##name, flags, namestring }
#define IMMEDIATE 1         /* immediate bit in flags */

#define CODE(name)       void F##name (void * pfa)
#define PRIMITIVE(name)  const void * T##name[] = { F##name }
#define THREAD(name)     const void * T##name[]
#define OFFSET(n)   (void *)(n*CELL)       /* see CELL above, = 4 */
#define LIT(n)      (void *)(n)


forth.h

/* begin */


int state ;

void toggle_LED(int pinNumber) {
  state = !state;
  digitalWrite(pinNumber, state);
}

void slowest() {
  for (volatile int iter = 9800; iter > 1; iter--) {
    ;
  }
}

void slower() {
  for (volatile int repeating = 25;
  repeating > 0; repeating--) {
    slowest();
  }
}

void this_here_now() {
  toggle_LED(15);
  slower();
  toggle_LED(15);
  for (int off_to_on_ratio = 7; off_to_on_ratio > 1; off_to_on_ratio--) {
    slower();
  }
  int test = 0;
  for (test = 22; test > 0; test--) {
    ;
  }
}

void this_here() {
  while(-1) {
    this_here_now(); // loop
  }
}
/* end */


fool.c

// #include <Arduino.h>


// #include <stdio.h>

/*

void putch(char c) {
    // printf(c); // dubious at best maybe
    // printf('b');
    // snprintf(c%, 'b', 1);
    fprintf(stderr, 'c');
    return ;  // doesn't have to do anything
}

*/
