force-lang 0.0.13 → 0.1.0

package/force

@@ -1,90 +1,90 @@
 #!/usr/bin/env node
 
-//const repl = require('repl');
-var program = require('commander');
-const log = require('bunny-logger');
-const readline = require('readline');
-const pkg = require('./package');
-const force = require('./src/force-lang');
-
-(async function main(){
-
-program
-  .version(pkg.version)
-  .usage('[options] <file ...>')
-  //.option('-f, --file [file]', 'input from file')
-  .option('-x, --exec [text]', 'input from string')
-  .option('-i, --shell', 'run repl')
-  .option('-s, --stdin', 'input from stdin (default action)')
-  .parse(process.argv);
-
-await force.load_lib();
-
-if(! (program.file || program.shell || program.exec || program.args[0])) program.stdin = true;
-
-if(program.file){
-	if(typeof(program.file)!=='string'){
-		log.error('no file given.');
-		process.exit(1);
-	}
-	await force.eval_file(program.file);
-}
-
-if(program.exec){
-	if(typeof(program.exec)!=='string'){
-		log.error('no input given.');
-		process.exit(1);
-	}
-	force.exec(program.exec);
-}
-if(program.shell){
-	//repl.start({prompt: '> ',eval: function(e){eval.eval(e);}});
-
-	force.populate_repl();
-
-	var buffered_line = '';
-
-	const rl = readline.createInterface({
-  	input: process.stdin,
-  	output: process.stdout,
-  	prompt: '> '
-	});
-
-	rl.prompt();
-
-	rl.on('line', (line) => {
-		if(line[line.length-1]==='\\'){
-			buffered_line += line.substr(0,line.length-1) +' ';
-			rl.setPrompt('... ');
-		} else {
-			if(buffered_line!=='') {
-				buffered_line += line;
-				force.exec(buffered_line);
-				buffered_line='';
-			}else {
-				force.exec(line);
-			}
-			rl.setPrompt('> ');
-		}
-		rl.prompt();
-	});
-}
-
-	if(program.args[0]){
-		await force.eval_file(program.args[0]);
-	}
-
-if(program.stdin){
-	//log.info(process.stdin);
-	var rl = readline.createInterface({
-  input: process.stdin,
-  output: process.stdout,
-  terminal: false
-});
-
-rl.on('line', function(line){
-    force.exec(line);
-})
-}
-
-})();
+// const repl = require('repl');
+import { Command } from 'commander';
+import log from 'bunny-logger';
+// import readline from 'readline';
+import readline from 'node:readline';
+import { stdin as input, stdout as output } from 'node:process';
+// const pkg = require('./package');
+// import pkg from './package.json' assert { type: 'json' };
+import { createRequire } from 'module';
+import force from './src/force-lang.js';
+
+(async function main() {
+  const program = new Command();
+  const require = createRequire(import.meta.url);
+  const pkg = require('./package.json');
+
+  program
+    .version(pkg.version)
+    .usage('[options] [file [args...]]')
+    .arguments('[files...]')
+    // .option('-f, --file [file]', 'input from file')
+    .option('-x, --exec [text]', 'input from string')
+    .option('-i, --shell', 'run repl')
+    .option('-s, --stdin', 'input from stdin (default action)')
+    .allowUnknownOption();
+  // .helpOption('-H, --help', 'display help for force');
+  program.parse(process.argv);
+  const options = program.opts();
+
+  await force.load_lib();
+
+  if (program.args.length > 0) {
+    const scriptFile = program.args[0];
+    const scriptArgs = program.args.slice(1);
+    process.argv = [process.argv[0], scriptFile, ...scriptArgs];
+    await force.eval_file(scriptFile);
+  } else if (options.exec) {
+    if (typeof options.exec !== 'string') {
+      log.error('no input given.');
+      process.exit(1);
+    }
+    await force.exec(options.exec);
+  } else if (options.shell) {
+    // repl.start({prompt: '> ',eval: function(e){eval.eval(e);}});
+
+    force.populate_repl();
+
+    let buffered_line = '';
+    input.setRawMode(true);
+    input.resume();
+
+    const rl = readline.createInterface({
+      input,
+      output,
+    });
+
+    rl.setPrompt('> ');
+    rl.prompt();
+
+    rl.on('line', async line => {
+      if (line[line.length - 1] === '\\') {
+        buffered_line += `${line.substr(0, line.length - 1)} `;
+        rl.setPrompt('... ');
+      } else {
+        if (buffered_line !== '') {
+          buffered_line += line;
+          await force.exec(buffered_line);
+          buffered_line = '';
+        } else {
+          await force.exec(line);
+        }
+        rl.setPrompt('> ');
+      }
+      rl.prompt();
+    });
+  } else {
+    // log.info(process.stdin);
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false,
+    });
+
+    rl.on('line', async line => {
+      await force.exec(line);
+    });
+  }
+})();

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "force-lang",
-  "version": "0.0.13",
+  "version": "0.1.0",
   "description": "a modern forth lang compatible with NodeJS",
+  "type": "module",
   "main": "./src/force-lang.js",
   "bin": {
     "force": "./force"
@@ -23,14 +24,12 @@
   },
   "dependencies": {
     "bunny-logger": "0.0.2",
-    "cheerio": "^1.0.0-rc.3",
-    "commander": "^2.19.0",
-    "format": "^0.2.2",
-    "json5": "^2.1.0",
-    "marked-man": "^0.2.1",
-    "request": "^2.88.0",
-    "request-promise-native": "^1.0.5",
-    "sync-request": "^6.0.0"
+    "cheerio": "^1.2.0",
+    "commander": "^14.0.2",
+    "got": "^14.6.6",
+    "json5": "^2.2.3",
+    "marked-man": "^2.1.0",
+    "sprintf-js": "^1.1.3"
   },
   "keywords": [
     "forth",
@@ -41,11 +40,14 @@
   ],
   "homepage": "https://github.com/elboza/force-lang.git",
   "devDependencies": {
-    "eslint": "^6.8.0",
-    "eslint-config-airbnb-base": "^14.1.0",
-    "eslint-config-prettier": "^6.10.1",
-    "eslint-plugin-import": "^2.20.2",
-    "eslint-plugin-prettier": "^3.1.2",
-    "prettier": "^2.0.4"
+    "eslint": "^8.57.1",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-prettier": "^5.5.5",
+    "prettier": "^3.8.1"
+  },
+  "resolutions": {
+    "moment": "2.29.4"
   }
 }

package/src/BKlib.j

@@ -0,0 +1,51 @@
+: cr
+	10 emit ;
+
+: true
+	T ;
+
+: false
+	F ;
+
+: is_truthy
+	is_falsy not ;
+
+: nip
+	swap drop ;
+
+: ddup
+	over over ;
+
+: ndrop2
+  dup is_num if
+  'no number on TOS' throw else
+  begin dup 0 > while 1 - swap drop repeat drop then
+  ;
+
+: ddrop
+	drop drop ;
+
+: f+
+	case
+	dup is_string of s:+ endof
+	over is_string of s:+ endof
+	dup is_list of a:+ endof
+	dup is_num of n:+ endof
+	endcase ;
+
+: a:join
+	s:join ;
+
+: j:encode
+	j:stringify ;
+
+: j:decode
+	j:parse ;
+
+: a:nth \ (a n -- o)
+	0 begin ddup > while >r >r a:tail r> r> 1 + repeat ddrop a:shift ;
+
+: s:chomp \ ( s -- s )
+	"" "\n$" rx:replace ;
+
+\ a:find notes \ [11,22,33] ( dup a:len begin dup 0 > while 1 - "q " . ddup a:nth .s repeat "f" . ) !!

package/src/env.js

@@ -1,163 +1,222 @@
-const log = require('bunny-logger');
-const Stack = require('./stack');
-
-class dict_obj{
-	constructor(){
-		this._type = null;
-		this._name = null;
-		this._datum = null;
-		this._where = null;
-	}
+import log from 'bunny-logger';
+import Stack from './stack.js';
+
+class dict_obj {
+  constructor() {
+    this._type = null;
+    this._name = null;
+    this._datum = null;
+    this._where = null;
+  }
+}
+class Env {
+  constructor() {
+    this._use_ns = false;
+    this._dict = [];
+    this._dict_ns = {};
+
+    this.s = new Stack();
+  }
+
+  print_stack() {
+    this.s.print();
+  }
+
+  TOS() {
+    return this.s.peek();
+  }
+
+  RTOS() {
+    return this.s.rpeek();
+  }
+
+  TOS2() {
+    return this.s.look_at(1);
+  }
+
+  is_bool(e) {
+    if (e && e._type == 'TC_BOOL') {
+      return true;
+    }
+    return false;
+  }
+
+  is_true(e) {
+    if (e && e._type == 'TC_BOOL' && e._datum == 'T') {
+      return true;
+    }
+    return false;
+  }
+
+  is_false(e) {
+    if (e && e._type == 'TC_BOOL' && e._datum == 'F') {
+      return true;
+    }
+    return false;
+  }
+
+  is_num(e) {
+    if (e && e._type == 'TC_NUM') {
+      return true;
+    }
+    return false;
+  }
+
+  is_string(e) {
+    if (e && e._type == 'TC_STR') {
+      return true;
+    }
+    return false;
+  }
+
+  is_json(e) {
+    if (e && e._type == 'TC_JSON') {
+      return true;
+    }
+    return false;
+  }
+
+  is_obj(e) {
+    if (e && e._type == 'TC_JSON' && !this.is_list(e)) {
+      return true;
+    }
+    return false;
+  }
+
+  is_list(e) {
+    if (e && e._type == 'TC_JSON' && e._datum instanceof Array) {
+      return true;
+    }
+    return false;
+  }
+
+  true_obj() {
+    return { _type: 'TC_BOOL', _datum: 'T' };
+  }
+
+  false_obj() {
+    return { _type: 'TC_BOOL', _datum: 'F' };
+  }
+
+  adj_bool_val(e) {
+    if (e === true) {
+      return 'T';
+    }
+    if (e === false) {
+      return 'F';
+    }
+    return e;
+  }
+
+  guess_type(e) {
+    switch (typeof e) {
+      case 'number':
+        return 'TC_NUM';
+        break;
+      case 'string':
+        return 'TC_STR';
+        break;
+      case 'object':
+        if (e instanceof Promise) {
+          return 'TC_PROMISE';
+        }
+        return 'TC_JSON';
+        break;
+      case 'boolean':
+        return 'TC_BOOL';
+        break;
+      case 'function':
+        return 'TC_FUNC_JS';
+        break;
+      default:
+        return 'TC_UNDEF';
+        break;
+    }
+  }
+
+  get_bool_val(e) {
+    if (this.is_bool(e)) {
+      if (this.is_true(e)) {
+        return true;
+      }
+      if (this.is_false(e)) {
+        return false;
+      }
+    }
+  }
+
+  set_bool_val(e) {
+    if (e === true) {
+      return this.true_obj();
+    }
+    if (e === false) {
+      return this.false_obj();
+    }
+  }
+
+  lookup_ns(name) {}
+
+  lookup_norm(name, type) {
+    for (const item of this._dict) {
+      // if(type && item._type == type)
+      if (item._name == name) {
+        return item;
+      }
+    }
+    return false;
+  }
+
+  lookup(name, type) {
+    return this.lookup_norm(name, type);
+  }
+
+  delete_norm(name) {
+    const index = this._dict.map(e => e._name).indexOf(name);
+    // log.info(index);
+    // log.info(this._dict[index]);
+    if (index >= 0) {
+      this._dict.splice(index, 1);
+    } else {
+      throw 'word not found.';
+    }
+  }
+
+  delete(name) {
+    return this.delete_norm(name);
+  }
+
+  set_ns(name, val) {}
+
+  set_norm(name, val, type, where) {
+    let x;
+    if ((x = this.lookup(name))) {
+      x._datum = val;
+    } else {
+      this.add_norm(name, val, type, where);
+    }
+  }
+
+  add_norm(name, val, type, where) {
+    let x;
+    x = new dict_obj();
+    x._type = type;
+    x._name = name;
+    x._datum = val;
+    x._where = where;
+    this._dict.unshift(x);
+  }
+
+  set(name, val, type, where) {
+    this.add_norm(name, val, type, where);
+    // this.set_norm(name, val, type, where);
+  }
+
+  print_debug() {
+    // log.info(this._dict);
+    this._dict.forEach(item => {
+      log.info(`${item._type} ${item._name} ${item._datum._type}`);
+    });
+  }
 }
-class Env{
-	constructor(){
-		this._use_ns = false;
-		this._dict = [];
-		this._dict_ns = {};
-
-		this.s = new Stack();
-	}
-	print_stack(){
-		this.s.print();
-	}
-	TOS(){
-		return this.s.peek();
-	}
-	TOS2(){
-		return this.s.look_at(1);
-	}
-	is_bool(e){
-		if(e && e._type=='TC_BOOL') return true;
-		return false;
-	}
-	is_true(e){
-		if(e && e._type=='TC_BOOL' && e._datum=='T') return true;
-		return false;
-	}
-	is_false(e){
-		if(e && e._type=='TC_BOOL' && e._datum=='F') return true;
-		return false;
-	}
-	is_num(e){
-		if(e && e._type=='TC_NUM') return true;
-		return false;
-	}
-	is_string(e){
-		if(e && e._type=='TC_STR') return true;
-		return false;
-	}
-	is_json(e){
-		if(e && e._type=='TC_JSON') return true;
-		return false;
-	}
-	is_obj(e){
-		if(e && e._type=='TC_JSON' && !this.is_list(e)) return true;
-		return false;
-	}
-	is_list(e){
-		if(e && e._type=='TC_JSON' && e._datum instanceof Array) return true;
-		return false;
-	}
-	true_obj(){
-		return {"_type":"TC_BOOL","_datum": 'T'};
-	}
-	false_obj(){
-		return {"_type":"TC_BOOL","_datum": 'F'};
-	}
-	adj_bool_val(e){
-		if(e===true) return 'T';
-		if(e===false) return 'F';
-		return e;
-	}
-	guess_type(e){
-		switch(typeof(e)){
-			case 'number':
-				return 'TC_NUM';
-				break;
-			case 'string':
-				return 'TC_STR';
-				break;
-			case 'object':
-				if(e instanceof Promise) return 'TC_PROMISE';
-				return 'TC_JSON';
-				break;
-			case 'boolean':
-				return 'TC_BOOL';
-				break;
-			case 'function':
-				return 'TC_FUNC_JS';
-				break;
-			default:
-				return 'TC_UNDEF';
-				break;
-		}
-	}
-	get_bool_val(e){
-		if(this.is_bool(e)){
-			if(this.is_true(e)) return true;
-			if(this.is_false(e)) return false;
-		}
-	}
-	set_bool_val(e){
-		if(e===true) return this.true_obj();
-		if(e===false) return this.false_obj();
-	}
-	lookup_ns(name){
-
-	}
-	lookup_norm(name, type){
-		for(var item of this._dict){
-			//if(type && item._type == type)
-			if(item._name == name) return item;
-		}
-		return false;
-	}
-	lookup(name, type){
-		return this.lookup_norm(name, type);
-	}
-	delete_norm(name){
-		let index = this._dict.map(function(e) { return e._name; }).indexOf(name);
-		//log.info(index);
-		//log.info(this._dict[index]);
-		if(index >= 0) {
-			this._dict.splice(index,1);
-		} else {
-			throw("word not found.");
-		}
-	}
-	delete(name){
-		return this.delete_norm(name);
-	}
-	set_ns(name, val){
-
-	}
-	set_norm(name, val, type, where){
-		var x;
-		if(x=this.lookup(name)){
-			x._datum = val;
-		}else{
-			this.add_norm(name, val, type, where);
-		}
-	}
-	add_norm(name, val, type, where){
-		var x;
-		x=new dict_obj();
-			x._type = type;
-			x._name = name;
-			x._datum = val;
-			x._where = where;
-			this._dict.unshift(x);
-	}
-	set(name, val, type, where){
-		this.add_norm(name, val, type, where);
-		//this.set_norm(name, val, type, where);
-	}
-	print_debug(){
-		//log.info(this._dict);
-		this._dict.forEach(item => {
-			log.info(`${item._type} ${item._name} ${item._datum._type}`);
-		});
-	}
-};
-
-module.exports = new Env();
+
+export default new Env();