@powerlang/egg-js/interpreter/EvaluationContext.js

A Smalltalk VM that runs on top of JavaScript

import ClosureElementTypes from './ClosureElementTypes.js';
import SAssociationBinding from './SAssociationBinding.js';
import SInstVarBinding from './SInstVarBinding.js';


let EvaluationContext = class  {

	constructor() {
		this._runtime = nil;
	}

	argumentAt_(anInteger) {
		return this.subclassResponsibility();
	}

	argumentAt_in_(anInteger, environmentIndex) {
		return this.subclassResponsibility();
	}

	arguments() {
		return this.subclassResponsibility();
	}

	backtrace() {
		return this.subclassResponsibility();
	}

	captureClosure_(anSBlock) {
		let closure, s, i, type, env, arg;
		closure = this._runtime.newClosureFor_(anSBlock.compiledCode());
		s = anSBlock.capturedVariables().readStream();
		i = 1;
		(() => {
			return s.atEnd()
		}).whileFalse_(() => {
			type = s.next();
			if (type._equal(Self))
			{
				closure.at_put_(i, this.self())
			}
			;
			if (type._equal(Environment))
			{
				closure.at_put_(i, this.environment())
			}
			;
			if (type._equal(EnvironmentValue))
			{
				env = this.environment().at_(s.next());
				closure.at_put_(i, env)
			}
			;
			if (type._equal(LocalArgument))
			{
				arg = this.argumentAt_(s.next());
				closure.at_put_(i, arg)
			}
			;
			if (type._equal(InlinedArgument))
			{
				arg = this.argumentAt_in_(s.next(), -1);
				closure.at_put_(i, arg)
			}
			;
			return i = (i+1)
		});
		return closure;
	}

	classBinding() {
		return this._runtime.methodClassBinding_(this.method());
	}

	environment() {
		return this.subclassResponsibility();
	}

	false() {
		return this._runtime.false();
	}

	firstArgument() {
		return this.subclassResponsibility();
	}

	fourthArgument() {
		return this.subclassResponsibility();
	}

	instanceVarAt_(index) {
		return this._runtime.instanceVarOf_at_(this.self(), index);
	}

	instanceVarAt_put_(index, value) {
		return this._runtime.instanceVarOf_at_put_(this.self(), index, value);
	}

	loadAssociationValue_(anObject) {
		return this._runtime.loadAssociationValue_(anObject);
	}

	method() {
		return this.subclassResponsibility();
	}

	method_(anSCompiledMethod) {
		return this.subclassResponsibility();
	}

	methodArguments() {
		return this.subclassResponsibility();
	}

	nil() {
		return this._runtime.nil();
	}

	receiver() {
		return this.subclassResponsibility();
	}

	runtime_(anEggRuntime) {
		this._runtime = anEggRuntime;
		return this;
	}

	secondArgument() {
		return this.subclassResponsibility();
	}

	self() {
		return this.subclassResponsibility();
	}

	stackTemporaryAt_(index) {
		return this.subclassResponsibility();
	}

	stackTemporaryAt_put_(index, value) {
		return this.subclassResponsibility();
	}

	staticBindingFor_(aSymbol) {
		let symbol, _condition;
		symbol = this._runtime.symbolFrom_(aSymbol);
		_condition = this.staticBindingForIvar_(symbol);
		if (nil !== _condition)
		{
			let b;
			b = _condition;
			return b
		}
		;
		_condition = this.staticBindingForCvar_(symbol);
		if (nil !== _condition)
		{
			let b;
			b = _condition;
			return b
		}
		;
		return this.staticBindingForMvar_(symbol);
	}

	staticBindingFor_inModule_(symbol, module) {
		let namespace, assoc;
		namespace = this._runtime.moduleNamespace_(module);
		assoc = this._runtime.lookupAssociationFor_in_(symbol, namespace);
		if (nil === assoc)
		{
			return nil
		}
		;
		return SAssociationBinding.new().association_(assoc);
	}

	staticBindingForCvar_(aSymbol) {
		let species, namespaces, namespace, nilObj, _condition, _retval;
		const _home =  {};
		try {
			species = this._runtime.methodClassBinding_(this.method());
			nilObj = this._runtime.nil();
			(() => {
				namespaces = this._runtime.speciesNamespaces_(species);
				(1).to_do_(namespaces.size(), (i) => {
					namespace = namespaces.at_(i);
					_condition = this._runtime.lookupAssociationFor_in_(aSymbol, namespace);
					_retval = nil;
					if (nil !== _condition)
					{
						let assoc;
						assoc = _condition;
						throw [_home, SAssociationBinding.new().association_(assoc)]
					}
					;
					return _retval
				});
				species = this._runtime.speciesSuperclass_(species);
				return species._equal(nilObj)
			}).whileFalse();
			return nil;
		} catch(e) { if (e[0] == _home) return e[1]; else throw(e); }
	}

	staticBindingForIvar_(aSymbol) {
		let ivar, _retval;
		ivar = this._runtime.staticBindingForIvar_in_(aSymbol, this.self());
		_retval = nil;
		if (ivar._greaterThan(0))
		{
			_retval = SInstVarBinding.new().index_(ivar)
		}
		;
		return _retval;
	}

	staticBindingForMvar_(symbol) {
		let module;
		module = this._runtime.methodModule_(this.method());
		return this.staticBindingFor_inModule_(symbol, module);
	}

	staticBindingForNested_(name) {
		let binding, module;
		binding = this.staticBindingFor_(name.at_(1));
		if (nil === binding)
		{
			return nil
		}
		;
		module = binding.valueWithin_(this);
		return this.staticBindingFor_inModule_(name.at_(2), module);
	}

	storeAssociation_value_(association, anObject) {
		this._runtime.storeAssociation_value_(association, anObject);
		return this;
	}

	temporaryAt_in_(index, environmentIndex) {
		return this.subclassResponsibility();
	}

	temporaryAt_in_put_(index, environmentIndex, value) {
		return this.subclassResponsibility();
	}

	thirdArgument() {
		return this.subclassResponsibility();
	}

	true() {
		return this._runtime.true();
	}

}

export default EvaluationContext