Return to b1com.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bint

BSD 4.3

/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */

/*
  $Header: /var/lib/cvsd/repos/CSRG/43BSD/contrib/B/src/bint/b1com.c,v 1.1.1.1 2018/04/24 16:12:54 root Exp $
*/

/************************************************************************/
/* B compounds                                                          */
/* plus Hows Funs and other odd types that don't fit anywhere else      */
/*                                                                      */
/* A compound is modelled as a sequence of len values, its fields.      */
/*                                                                      */
/************************************************************************/

#include "b.h"
#include "b1obj.h"
#include "b2nod.h"

/* NODES */

Visible typenode nodetype(v) parsetree v; {
	return Is_parsetree(v) ? Nodetype(v) : Nonode;
}

Hidden value
mk_ptn(type, len) /* make parsetree node */
	typenode type;
	intlet len;
{
	parsetree v= (parsetree) grab_ptn((len<<8) | type);
	*Branch(v, len)= *Branch(v, len+1)= NilTree;
	return v;
}

Visible parsetree
node1(type)
	typenode type;
{
	return mk_ptn(type, 0);
}

Visible parsetree
node2(type, a1)
	typenode type; value a1;
{
	parsetree v= mk_ptn(type, 1); value *p= Ats(v);
	*p++= a1;
	return v;
}

Visible parsetree
node3(type, a1, a2)
	typenode type; value a1, a2;
{
	parsetree v= mk_ptn(type, 2); value *p= Ats(v);
	*p++= a1; *p++= a2;
	return v;
}

Visible parsetree
node4(type, a1, a2, a3)
	typenode type; value a1, a2, a3;
{
	parsetree v= mk_ptn(type, 3); value *p= Ats(v);
	*p++= a1; *p++= a2; *p++= a3;
	return v;
}

Visible parsetree
node5(type, a1, a2, a3, a4)
	typenode type; value a1, a2, a3, a4;
{
	parsetree v= mk_ptn(type, 4); value *p= Ats(v);
	*p++= a1; *p++= a2; *p++= a3; *p++= a4;
	return v;
}

Visible parsetree
node6(type, a1, a2, a3, a4,a5)
	typenode type; value a1, a2, a3, a4, a5;
{
	parsetree v= mk_ptn(type, 5); value *p= Ats(v);
	*p++= a1; *p++= a2; *p++= a3; *p++= a4; *p++= a5;
	return v;
}

Visible parsetree
node8(type, a1, a2, a3, a4, a5, a6, a7)
	typenode type; value a1, a2, a3, a4, a5, a6, a7;
{
	parsetree v= mk_ptn(type, 7); value *p= Ats(v);
	*p++= a1; *p++= a2; *p++= a3; *p++= a4; *p++= a5; *p++= a6; *p++= a7;
	return v;
}

Visible parsetree
node9(type, a1, a2, a3, a4, a5, a6, a7, a8)
	typenode type; value a1, a2, a3, a4, a5, a6, a7, a8;
{
	parsetree v= mk_ptn(type, 8); value *p= Ats(v);
	*p++= a1; *p++= a2; *p++= a3; *p++= a4; *p++= a5; *p++= a6;
	*p++= a7; *p++= a8;
	return v;
}

/* OTHER TYPES */

Visible loc
mk_simploc(id, en)
	basidf id; env en;
{
	loc l= grab_sim();
	(*Ats(l))= copy(id); (*(Ats(l)+1))= (value) en;
	return l;
}

Visible loc
mk_trimloc(R, B, C)
	loc R; value B, C;
{
	loc l= grab_tri(); trimloc *ll= (trimloc *)Ats(l);
	ll->R= copy(R); ll->B= copy(B); ll->C= copy(C);
	return l;
}

Visible loc
mk_tbseloc(R, K)
	loc R; value K;
{
	loc l= grab_tse(); tbseloc *ll= (tbseloc *)Ats(l);
	ll->R= copy(R); ll->K= copy(K);
	return l;
}

Visible fun
mk_fun(adic, pre, unit, filed)
	literal adic; intlet pre; parsetree unit; bool filed;
{
	fun f= grab_fun(); funprd *ff= (funprd *)Ats(f);
	ff->adic= adic; ff->pre= pre; ff->unit= unit;
	ff->unparsed= Yes; ff->filed= filed;
	ff->code= NilTree;
	return f;
}

Visible prd
mk_prd(adic, pre, unit, filed)
	literal adic; intlet pre; parsetree unit; bool filed;
{
	prd p= grab_prd(); funprd *pp= (funprd *)Ats(p);
	pp->adic= adic; pp->pre= pre; pp->unit= unit;
	pp->unparsed= Yes; pp->filed= filed;
	pp->code= NilTree;
	return p;
}

Visible value
mk_how(unit, filed)
	parsetree unit; bool filed;
{
	value h= grab_how(); how *hh= (how *)Ats(h);
	hh->unit= unit; hh->unparsed= Yes; hh->filed= filed;
	hh->code= NilTree;
	return h;
}

Visible value
mk_ref(rp)
	parsetree rp;
{
	value r= grab_ref();
	*Ats(r)= copy(rp);
	return r;
}

Visible value
mk_per(v)
	value v;
{
	value p= grab_per();
	*Ats(p)= copy(v);
	return p;
}

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.