d0p1/ack
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

some changes to make smaller

Browse source
This commit is contained in:
ceriel 1987-05-21 09:37:28 +00:00
parent dd2cf6bbaa
commit ed2d6ab75b
6 changed files with 184 additions and 144 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
lang/m2/comp/cstoper.c
View file

@ -332,27 +332,29 @@ cstset(expp)
} }
expp->nd_class = Value; expp->nd_class = Value;
expp->nd_symb = INTEGER; expp->nd_symb = INTEGER;
if (expp->nd_left->nd_set) { freesets(expp);
free((char *) expp->nd_left->nd_set);
}
if (expp->nd_right->nd_set) {
free((char *) expp->nd_right->nd_set);
}
FreeNode(expp->nd_left);
FreeNode(expp->nd_right);
expp->nd_left = expp->nd_right = 0;
return; return;
default: default:
crash("(cstset)"); crash("(cstset)");
} }
if (expp->nd_right->nd_set) { freesets(expp);
free((char *) expp->nd_right->nd_set);
}
if (expp->nd_left->nd_set) {
free((char *) expp->nd_left->nd_set);
}
expp->nd_class = Set; expp->nd_class = Set;
expp->nd_set = resultset; expp->nd_set = resultset;
return;
}
FreeNode(expp->nd_left);
FreeNode(expp->nd_right);
expp->nd_left = expp->nd_right = 0;
}
freesets(expp)
register struct node *expp;
{
if (expp->nd_right->nd_set) {
free((char *) expp->nd_right->nd_set);
}
if (expp->nd_left->nd_set) {
free((char *) expp->nd_left->nd_set);
} }
FreeNode(expp->nd_left); FreeNode(expp->nd_left);
FreeNode(expp->nd_right); FreeNode(expp->nd_right);

81
lang/m2/comp/desig.c
View file

@ -33,6 +33,45 @@
extern int proclevel; extern int proclevel;
struct desig InitDesig = {DSG_INIT, 0, 0}; struct desig InitDesig = {DSG_INIT, 0, 0};
int C_ste_dnam(), C_sde_dnam(), C_loe_dnam(), C_lde_dnam();
int C_stl(), C_sdl(), C_lol(), C_ldl();
#define WRD 0
#define DWRD 1
#define LD 0
#define STR 1
static int (*lcl_ld_and_str[2][2])() = {
{ C_lol, C_stl },
{ C_ldl, C_sdl }
};
static int (*ext_ld_and_str[2][2])() = {
{ C_loe_dnam, C_ste_dnam },
{ C_lde_dnam, C_sde_dnam }
};
int
DoLoadOrStore(ds, size, LoadOrStoreFlag)
register struct desig *ds;
{
int sz;
if (ds->dsg_offset % word_size != 0) return 0;
if (size == word_size) sz = WRD;
else if (size == dword_size) sz = DWRD;
else return 0;
if (ds->dsg_name) {
(*(ext_ld_and_str[sz][LoadOrStoreFlag]))(ds->dsg_name, ds->dsg_offset);
}
else {
(*(lcl_ld_and_str[sz][LoadOrStoreFlag]))(ds->dsg_offset);
}
return 1;
}
STATIC int STATIC int
properly(ds, size, al) properly(ds, size, al)
register struct desig *ds; register struct desig *ds;
@ -73,23 +112,7 @@ CodeValue(ds, size, al)
break; break;
case DSG_FIXED: case DSG_FIXED:
if (ds->dsg_offset % word_size == 0) { if (DoLoadOrStore(ds, size, LD)) break;
if (size == word_size) {
if (ds->dsg_name) {
C_loe_dnam(ds->dsg_name,ds->dsg_offset);
}
else C_lol(ds->dsg_offset);
break;
}
if (size == dword_size) {
if (ds->dsg_name) {
C_lde_dnam(ds->dsg_name,ds->dsg_offset);
}
else C_ldl(ds->dsg_offset);
break;
}
}
/* Fall through */ /* Fall through */
case DSG_PLOADED: case DSG_PLOADED:
case DSG_PFIXED: case DSG_PFIXED:
@ -138,23 +161,7 @@ CodeStore(ds, size, al)
save = *ds; save = *ds;
switch(ds->dsg_kind) { switch(ds->dsg_kind) {
case DSG_FIXED: case DSG_FIXED:
if (ds->dsg_offset % word_size == 0) { if (DoLoadOrStore(ds, size, STR)) break;
if (size == word_size) {
if (ds->dsg_name) {
C_ste_dnam(ds->dsg_name,ds->dsg_offset);
}
else C_stl(ds->dsg_offset);
break;
}
if (size == dword_size) {
if (ds->dsg_name) {
C_sde_dnam(ds->dsg_name,ds->dsg_offset);
}
else C_sdl(ds->dsg_offset);
break;
}
}
/* Fall through */ /* Fall through */
case DSG_PLOADED: case DSG_PLOADED:
case DSG_PFIXED: case DSG_PFIXED:
@ -343,11 +350,7 @@ CodeAddress(ds)
break; break;
case DSG_PFIXED: case DSG_PFIXED:
if (ds->dsg_name) { DoLoadOrStore(ds, word_size, LD);
C_loe_dnam(ds->dsg_name,ds->dsg_offset);
break;
}
C_lol(ds->dsg_offset);
break; break;
case DSG_INDEXED: case DSG_INDEXED:

11
lang/m2/comp/enter.c
View file

@ -43,6 +43,17 @@ Enter(name, kind, type, pnam)
return df; return df;
} }
EnterType(name, type)
char *name;
struct type *type;
{
/* Enter a type definition for "name" and type
"type" in the Current Scope.
*/
Enter(name, D_TYPE, type, 0);
}
EnterEnumList(Idlist, type) EnterEnumList(Idlist, type)
struct node *Idlist; struct node *Idlist;
register struct type *type; register struct type *type;

79
lang/m2/comp/main.c
View file

@ -148,49 +148,58 @@ LexScan()
} }
#endif #endif
static struct stdproc {
char *st_nam;
int st_con;
} stdproc[] = {
{ "ABS", S_ABS },
{ "CAP", S_CAP },
{ "CHR", S_CHR },
{ "FLOAT", S_FLOAT },
{ "HIGH", S_HIGH },
{ "HALT", S_HALT },
{ "EXCL", S_EXCL },
{ "DEC", S_DEC },
{ "INC", S_INC },
{ "VAL", S_VAL },
{ "NEW", S_NEW },
{ "DISPOSE", S_DISPOSE },
{ "TRUNC", S_TRUNC },
{ "SIZE", S_SIZE },
{ "ORD", S_ORD },
{ "ODD", S_ODD },
{ "MAX", S_MAX },
{ "MIN", S_MIN },
{ "INCL", S_INCL },
{ 0, 0 }
};
extern struct def *Enter();
AddStandards() AddStandards()
{ {
register struct def *df; register struct def *df;
extern struct def *Enter(); register struct stdproc *p;
static struct node nilnode = { 0, 0, Value, 0, { INTEGER, 0}}; static struct node nilnode = { 0, 0, Value, 0, { INTEGER, 0}};
Enter("ABS", D_PROCEDURE, std_type, S_ABS); for (p = stdproc; p->st_nam != 0; p++) {
Enter("CAP", D_PROCEDURE, std_type, S_CAP); Enter(p->st_nam, D_PROCEDURE, std_type, p->st_con);
Enter("CHR", D_PROCEDURE, std_type, S_CHR); }
Enter("FLOAT", D_PROCEDURE, std_type, S_FLOAT);
Enter("HIGH", D_PROCEDURE, std_type, S_HIGH);
Enter("HALT", D_PROCEDURE, std_type, S_HALT);
Enter("EXCL", D_PROCEDURE, std_type, S_EXCL);
Enter("DEC", D_PROCEDURE, std_type, S_DEC);
Enter("INC", D_PROCEDURE, std_type, S_INC);
Enter("VAL", D_PROCEDURE, std_type, S_VAL);
Enter("NEW", D_PROCEDURE, std_type, S_NEW);
Enter("DISPOSE", D_PROCEDURE, std_type, S_DISPOSE);
Enter("TRUNC", D_PROCEDURE, std_type, S_TRUNC);
Enter("SIZE", D_PROCEDURE, std_type, S_SIZE);
Enter("ORD", D_PROCEDURE, std_type, S_ORD);
Enter("ODD", D_PROCEDURE, std_type, S_ODD);
Enter("MAX", D_PROCEDURE, std_type, S_MAX);
Enter("MIN", D_PROCEDURE, std_type, S_MIN);
Enter("INCL", D_PROCEDURE, std_type, S_INCL);
Enter("CHAR", D_TYPE, char_type, 0); EnterType("CHAR", char_type);
Enter("INTEGER", D_TYPE, int_type, 0); EnterType("INTEGER", int_type);
Enter("LONGINT", D_TYPE, longint_type, 0); EnterType("LONGINT", longint_type);
Enter("REAL", D_TYPE, real_type, 0); EnterType("REAL", real_type);
Enter("LONGREAL", D_TYPE, longreal_type, 0); EnterType("LONGREAL", longreal_type);
Enter("BOOLEAN", D_TYPE, bool_type, 0); EnterType("BOOLEAN", bool_type);
Enter("CARDINAL", D_TYPE, card_type, 0); EnterType("CARDINAL", card_type);
df = Enter("NIL", D_CONST, address_type, 0); df = Enter("NIL", D_CONST, address_type, 0);
df->con_const = &nilnode; df->con_const = &nilnode;
nilnode.nd_INT = 0; nilnode.nd_INT = 0;
nilnode.nd_type = address_type; nilnode.nd_type = address_type;
Enter("PROC", EnterType("PROC", construct_type(T_PROCEDURE, NULLTYPE));
D_TYPE, EnterType("BITSET", bitset_type);
construct_type(T_PROCEDURE, NULLTYPE),
0);
df = Enter("BITSET", D_TYPE, bitset_type, 0);
df = Enter("TRUE", D_ENUM, bool_type, 0); df = Enter("TRUE", D_ENUM, bool_type, 0);
df->enm_val = 1; df->enm_val = 1;
df->enm_next = Enter("FALSE", D_ENUM, bool_type, 0); df->enm_next = Enter("FALSE", D_ENUM, bool_type, 0);
@ -206,9 +215,9 @@ do_SYSTEM()
static char systemtext[] = SYSTEMTEXT; static char systemtext[] = SYSTEMTEXT;
open_scope(CLOSEDSCOPE); open_scope(CLOSEDSCOPE);
Enter("WORD", D_TYPE, word_type, 0); EnterType("WORD", word_type);
Enter("BYTE", D_TYPE, byte_type, 0); EnterType("BYTE", byte_type);
Enter("ADDRESS", D_TYPE, address_type, 0); EnterType("ADDRESS",address_type);
Enter("ADR", D_PROCEDURE, std_type, S_ADR); Enter("ADR", D_PROCEDURE, std_type, S_ADR);
Enter("TSIZE", D_PROCEDURE, std_type, S_TSIZE); Enter("TSIZE", D_PROCEDURE, std_type, S_TSIZE);
if (!InsertText(systemtext, sizeof(systemtext) - 1)) { if (!InsertText(systemtext, sizeof(systemtext) - 1)) {

64
lang/m2/comp/options.c
View file

@ -141,12 +141,14 @@ DoOption(text)
case 'V' : /* set object sizes and alignment requirements */ case 'V' : /* set object sizes and alignment requirements */
{ {
arith size; register arith size;
int align; register int align;
char c; char c;
char *t; char *t;
while (c = *text++) { while (c = *text++) {
char *strindex();
t = text; t = text;
size = txt2int(&t); size = txt2int(&t);
align = 0; align = 0;
@ -155,44 +157,60 @@ DoOption(text)
align = txt2int(&t); align = txt2int(&t);
text = t; text = t;
} }
switch (c) { if (! strindex("wislfdpS", c)) {
error("-V: bad type indicator %c\n", c);
}
if (size != 0) switch (c) {
case 'w': /* word */ case 'w': /* word */
if (size != (arith)0) { word_size = size;
word_size = size; dword_size = 2 * size;
dword_size = 2 * size;
}
if (align != 0) word_align = align;
break; break;
case 'i': /* int */ case 'i': /* int */
if (size != (arith)0) int_size = size; int_size = size;
if (align != 0) int_align = align;
break; break;
case 's': /* short (subranges) */ case 's': /* short (subranges) */
if (size != 0) short_size = size; short_size = size;
if (align != 0) short_align = align;
break; break;
case 'l': /* longint */ case 'l': /* longint */
if (size != (arith)0) long_size = size; long_size = size;
if (align != 0) long_align = align;
break; break;
case 'f': /* real */ case 'f': /* real */
if (size != (arith)0) float_size = size; float_size = size;
if (align != 0) float_align = align;
break; break;
case 'd': /* longreal */ case 'd': /* longreal */
if (size != (arith)0) double_size = size; double_size = size;
if (align != 0) double_align = align;
break; break;
case 'p': /* pointer */ case 'p': /* pointer */
if (size != (arith)0) pointer_size = size; pointer_size = size;
if (align != 0) pointer_align = align; break;
}
if (align != 0) switch (c) {
case 'w': /* word */
word_align = align;
break;
case 'i': /* int */
int_align = align;
break;
case 's': /* short (subranges) */
short_align = align;
break;
case 'l': /* longint */
long_align = align;
break;
case 'f': /* real */
float_align = align;
break;
case 'd': /* longreal */
double_align = align;
break;
case 'p': /* pointer */
pointer_align = align;
break; break;
case 'S': /* initial record alignment */ case 'S': /* initial record alignment */
if (align != (arith)0) struct_align = align; struct_align = align;
break; break;
default:
error("-V: bad type indicator %c\n", c);
} }
} }
break; break;

61
lang/m2/comp/tmpvar.C
View file

@ -59,64 +59,61 @@ TmpSpace(sz, al)
return sc->sc_off; return sc->sc_off;
} }
arith STATIC arith
NewInt() NewTmp(plist, sz, al, regtype)
struct tmpvar **plist;
arith sz;
{ {
register arith offset; register arith offset;
register struct tmpvar *tmp; register struct tmpvar *tmp;
if (!TmpInts) { if (!*plist) {
offset = TmpSpace(int_size, int_align); offset = TmpSpace(sz, al);
if (! options['n']) C_ms_reg(offset, int_size, reg_any, 0); if (! options['n']) C_ms_reg(offset, sz, regtype, 0);
} }
else { else {
tmp = TmpInts; tmp = *plist;
offset = tmp->t_offset; offset = tmp->t_offset;
TmpInts = tmp->next; *plist = tmp->next;
free_tmpvar(tmp); free_tmpvar(tmp);
} }
return offset; return offset;
} }
arith
NewInt()
{
return NewTmp(&TmpInts, int_size, int_align, reg_any);
}
arith arith
NewPtr() NewPtr()
{ {
register arith offset; return NewTmp(&TmpPtrs, pointer_size, pointer_align, reg_pointer);
register struct tmpvar *tmp; }
if (!TmpPtrs) { STATIC
offset = TmpSpace(pointer_size, pointer_align); FreeTmp(plist, off)
if (! options['n']) C_ms_reg(offset, pointer_size, reg_pointer, 0); struct tmpvar **plist;
} arith off;
else { {
tmp = TmpPtrs; register struct tmpvar *tmp = new_tmpvar();
offset = tmp->t_offset;
TmpPtrs = tmp->next; tmp->next = *plist;
free_tmpvar(tmp); tmp->t_offset = off;
} *plist = tmp;
return offset;
} }
FreeInt(off) FreeInt(off)
arith off; arith off;
{ {
register struct tmpvar *tmp; FreeTmp(&TmpInts, off);
tmp = new_tmpvar();
tmp->next = TmpInts;
tmp->t_offset = off;
TmpInts = tmp;
} }
FreePtr(off) FreePtr(off)
arith off; arith off;
{ {
register struct tmpvar *tmp; FreeTmp(&TmpPtrs, off);
tmp = new_tmpvar();
tmp->next = TmpPtrs;
tmp->t_offset = off;
TmpPtrs = tmp;
} }
TmpClose() TmpClose()