Initial revision
This commit is contained in:
sater
757
util/misc/encode.c
Normal file
757
util/misc/encode.c
Normal file
@@ -0,0 +1,757 @@
|
||||
/*
|
||||
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||
*
|
||||
* This product is part of the Amsterdam Compiler Kit.
|
||||
*
|
||||
* Permission to use, sell, duplicate or disclose this software must be
|
||||
* obtained in writing. Requests for such permissions may be sent to
|
||||
*
|
||||
* Dr. Andrew S. Tanenbaum
|
||||
* Wiskundig Seminarium
|
||||
* Vrije Universiteit
|
||||
* Postbox 7161
|
||||
* 1007 MC Amsterdam
|
||||
* The Netherlands
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* Encode to compact EM assembly language
|
||||
*
|
||||
* Author: Johan Stevenson, Vrije Universiteit, Amsterdam
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <ctype.h>
|
||||
#include <assert.h>
|
||||
#include <setjmp.h>
|
||||
#include <em_spec.h>
|
||||
#include <em_pseu.h>
|
||||
#include <em_flag.h>
|
||||
#include <em_ptyp.h>
|
||||
#include <em_mes.h>
|
||||
|
||||
#define put8(x) putchar(x)
|
||||
|
||||
#define check(x) if (!(x)) fail_check()
|
||||
|
||||
#define fit16i(x) ((x) >= 0xFFFF8000 && (x) <= 0x00007FFF)
|
||||
#define fit8u(x) ((x) >= 0 && (x) <= 0xFF)
|
||||
|
||||
#define MAXSTR 256
|
||||
#define HSIZE 256
|
||||
#define EMPTY (EOF-1)
|
||||
|
||||
/*
|
||||
* global variables
|
||||
*/
|
||||
|
||||
int opcode;
|
||||
int offtyp;
|
||||
long argval;
|
||||
int dlbval;
|
||||
char string[MAXSTR];
|
||||
int strsiz;
|
||||
|
||||
int wsize;
|
||||
int psize;
|
||||
int lineno;
|
||||
int argnum;
|
||||
int errors;
|
||||
char *progname;
|
||||
char *filename = "INPUT";
|
||||
|
||||
long wordmask[] = { /* allowed bits in a word */
|
||||
0x00000000,
|
||||
0x000000FF,
|
||||
0x0000FFFF,
|
||||
0x00000000,
|
||||
0xFFFFFFFF
|
||||
};
|
||||
|
||||
long sizemask[] = { /* allowed bits in multiples of 'wsize' */
|
||||
0x00000000,
|
||||
0x7FFFFFFF,
|
||||
0x7FFFFFFE,
|
||||
0x00000000,
|
||||
0x7FFFFFFC
|
||||
};
|
||||
|
||||
int peekc = EMPTY;
|
||||
int hashtab[HSIZE];
|
||||
jmp_buf recover;
|
||||
|
||||
/*
|
||||
* external tables
|
||||
*/
|
||||
|
||||
extern char em_flag[];
|
||||
extern short em_ptyp[];
|
||||
extern char em_mnem[][4];
|
||||
extern char em_pseu[][4];
|
||||
|
||||
int main(argc,argv) char **argv; {
|
||||
|
||||
progname = argv[0];
|
||||
if (argc >= 2) {
|
||||
filename = argv[1];
|
||||
if (freopen(filename,"r",stdin) == NULL)
|
||||
fatal("can't open %s",filename);
|
||||
}
|
||||
if (argc >= 3)
|
||||
if (freopen(argv[2],"w",stdout) == NULL)
|
||||
fatal("can't create %s",argv[2]);
|
||||
init();
|
||||
put16(sp_magic);
|
||||
setjmp(recover);
|
||||
while (nextline())
|
||||
;
|
||||
return(errors ? -1 : 0);
|
||||
}
|
||||
|
||||
/* ----- copy ----- */
|
||||
|
||||
int nextline() {
|
||||
register c,i;
|
||||
|
||||
lineno++;
|
||||
argnum = 1;
|
||||
c = nextchar();
|
||||
if (c == EOF)
|
||||
return(0);
|
||||
if (isspace(c) && c != '\n') {
|
||||
c = nospace();
|
||||
if (isalpha(c)) {
|
||||
inmnem(c);
|
||||
if (opcode <= sp_lmnem)
|
||||
instr();
|
||||
else
|
||||
pseudo();
|
||||
} else
|
||||
peekc = c;
|
||||
} else if (c == '#') {
|
||||
line_line();
|
||||
} else {
|
||||
peekc = c;
|
||||
i = gettyp(sym_ptyp | ptyp(sp_cst2) | ptyp(sp_cend));
|
||||
switch (i) {
|
||||
case sp_cst2:
|
||||
i = (int) argval;
|
||||
if (i >= 0 && i < sp_nilb0)
|
||||
put8(i + sp_filb0);
|
||||
else
|
||||
putarg(sp_ilb2);
|
||||
break;
|
||||
case sp_dlb2:
|
||||
case sp_dnam:
|
||||
putarg(i);
|
||||
break;
|
||||
case sp_cend:
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (nospace() != '\n')
|
||||
syntax("end of line expected");
|
||||
return(1);
|
||||
}
|
||||
|
||||
instr() {
|
||||
register i,j,t;
|
||||
register long l;
|
||||
|
||||
i = opcode;
|
||||
put8(i);
|
||||
i -= sp_fmnem;
|
||||
j = em_flag[i] & EM_PAR;
|
||||
if (j == PAR_NO)
|
||||
return;
|
||||
t = em_ptyp[j];
|
||||
if (j == PAR_B)
|
||||
t = ptyp(sp_ilb2);
|
||||
t = getarg(t);
|
||||
/*
|
||||
* range checking
|
||||
*/
|
||||
switch (j) {
|
||||
case PAR_N:
|
||||
check(argval >= 0);
|
||||
break;
|
||||
case PAR_G:
|
||||
if (t != sp_cst2 && t != sp_cst4)
|
||||
break;
|
||||
check(argval >= 0);
|
||||
/* fall through */
|
||||
case PAR_L:
|
||||
l = argval >= 0 ? argval : -argval;
|
||||
check((l & ~wordmask[psize]) == 0);
|
||||
break;
|
||||
case PAR_W:
|
||||
if (t == sp_cend)
|
||||
break;
|
||||
check((argval & ~wordmask[wsize]) == 0);
|
||||
/* fall through */
|
||||
case PAR_S:
|
||||
check(argval != 0);
|
||||
/* fall through */
|
||||
case PAR_Z:
|
||||
check((argval & ~sizemask[wsize]) == 0);
|
||||
break;
|
||||
case PAR_O:
|
||||
check(argval != 0);
|
||||
check((argval & ~sizemask[wsize])==0 || (wsize % argval)==0);
|
||||
break;
|
||||
case PAR_B:
|
||||
t = sp_cst2;
|
||||
break;
|
||||
case PAR_R:
|
||||
check(argval >= 0 && argval <= 2);
|
||||
break;
|
||||
}
|
||||
putarg(t);
|
||||
}
|
||||
|
||||
pseudo() {
|
||||
register i,t;
|
||||
|
||||
i = opcode;
|
||||
put8(i);
|
||||
switch (i) {
|
||||
case ps_bss:
|
||||
case ps_hol:
|
||||
putarg(getarg(cst_ptyp));
|
||||
putarg(getarg(val_ptyp));
|
||||
putarg(getarg(ptyp(sp_cst2)));
|
||||
check(argval==0 || argval==1);
|
||||
break;
|
||||
case ps_rom:
|
||||
case ps_con:
|
||||
putarg(getarg(val_ptyp));
|
||||
do
|
||||
putarg(t = getarg(any_ptyp));
|
||||
while (t != sp_cend);
|
||||
break;
|
||||
case ps_mes:
|
||||
putarg(getarg(ptyp(sp_cst2)));
|
||||
if (argval == ms_emx) {
|
||||
putarg(getarg(ptyp(sp_cst2)));
|
||||
check(argval > 0 && argval <= 4);
|
||||
wsize = (int) argval;
|
||||
putarg(getarg(ptyp(sp_cst2)));
|
||||
check(argval > 0 && argval <= 4);
|
||||
psize = (int) argval;
|
||||
}
|
||||
do
|
||||
putarg(t = getarg(any_ptyp));
|
||||
while (t != sp_cend);
|
||||
break;
|
||||
case ps_exa:
|
||||
case ps_ina:
|
||||
putarg(getarg(sym_ptyp));
|
||||
break;
|
||||
case ps_exp:
|
||||
case ps_inp:
|
||||
putarg(getarg(ptyp(sp_pnam)));
|
||||
break;
|
||||
case ps_exc:
|
||||
putarg(getarg(ptyp(sp_cst2)));
|
||||
putarg(getarg(ptyp(sp_cst2)));
|
||||
break;
|
||||
case ps_pro:
|
||||
putarg(getarg(ptyp(sp_pnam)));
|
||||
putarg(getarg(cst_ptyp|ptyp(sp_cend)));
|
||||
break;
|
||||
case ps_end:
|
||||
putarg(getarg(cst_ptyp|ptyp(sp_cend)));
|
||||
break;
|
||||
default:
|
||||
syntax("bad pseudo %d",i);
|
||||
}
|
||||
}
|
||||
|
||||
/* ----- input ----- */
|
||||
|
||||
int getarg(typset) {
|
||||
register c;
|
||||
|
||||
if (argnum != 1) {
|
||||
c = nospace();
|
||||
if (c != ',') {
|
||||
if (c != '\n')
|
||||
syntax("comma expected");
|
||||
peekc = c;
|
||||
}
|
||||
}
|
||||
argnum++;
|
||||
return(gettyp(typset));
|
||||
}
|
||||
|
||||
int gettyp(typset) {
|
||||
register c,t,sp;
|
||||
|
||||
c = nospace();
|
||||
if (c == '\n') {
|
||||
peekc = c;
|
||||
sp = sp_cend;
|
||||
} else if (isdigit(c) || c == '+' || c == '-' || c == '(') {
|
||||
sp = inexpr1(c);
|
||||
if (sp == sp_cst4 && fit16i(argval))
|
||||
sp = sp_cst2;
|
||||
} else if (isalpha(c)) {
|
||||
inname(c);
|
||||
sp = offsetted(sp_dnam);
|
||||
} else if (c == '.') {
|
||||
in15u();
|
||||
dlbval = (int) argval;
|
||||
sp = offsetted(sp_dlb2);
|
||||
} else if (c == '*') {
|
||||
in15u();
|
||||
sp = sp_ilb2;
|
||||
} else if (c == '$') {
|
||||
inname(nextchar());
|
||||
sp = sp_pnam;
|
||||
} else if (c == '"' || c == '\'') {
|
||||
sp = instring(c);
|
||||
} else if (c == '?') {
|
||||
sp = sp_cend;
|
||||
} else
|
||||
syntax("operand expected");
|
||||
t = sp - sp_fspec;
|
||||
assert(t >= 0 && t < 16);
|
||||
t = 1 << t;
|
||||
if ((typset & t) == 0)
|
||||
error("bad argument type %d",sp);
|
||||
return(sp);
|
||||
}
|
||||
|
||||
int offsetted(sp) {
|
||||
register c;
|
||||
|
||||
c = nospace();
|
||||
if (c == '+' || c == '-') {
|
||||
gettyp(cst_ptyp);
|
||||
if (c == '-')
|
||||
argval = -argval;
|
||||
offtyp = sp;
|
||||
return(sp_doff);
|
||||
}
|
||||
peekc = c;
|
||||
return(sp);
|
||||
}
|
||||
|
||||
inname(c) register c; {
|
||||
register char *p;
|
||||
|
||||
if (isalpha(c) == 0)
|
||||
syntax("letter expected");
|
||||
p = string;
|
||||
do {
|
||||
if (p < &string[MAXSTR-1])
|
||||
*p++ = c;
|
||||
c = nextchar();
|
||||
} while (isalnum(c));
|
||||
peekc = c;
|
||||
*p = '\0';
|
||||
strsiz = p - string;
|
||||
}
|
||||
|
||||
int inmnem(c) register c; {
|
||||
register unsigned h;
|
||||
register i;
|
||||
|
||||
inname(c);
|
||||
h = hash(string);
|
||||
for (;;) {
|
||||
h++;
|
||||
h %= HSIZE;
|
||||
i = hashtab[h];
|
||||
if (i == 0)
|
||||
syntax("bad mnemonic");
|
||||
if (i <= sp_lmnem) {
|
||||
assert(i >= sp_fmnem);
|
||||
if (strcmp(string,em_mnem[i - sp_fmnem]) != 0)
|
||||
continue;
|
||||
return(opcode = i);
|
||||
}
|
||||
assert(i <= sp_lpseu && i >= sp_fpseu);
|
||||
if (strcmp(string,em_pseu[i - sp_fpseu]) != 0)
|
||||
continue;
|
||||
return(opcode = i);
|
||||
}
|
||||
}
|
||||
|
||||
int inexpr1(c) register c; {
|
||||
long left;
|
||||
|
||||
if ((c = inexpr2(c)) != sp_cst4)
|
||||
return(c);
|
||||
for (;;) {
|
||||
c = nospace();
|
||||
if (c != '+' && c != '-') {
|
||||
peekc = c;
|
||||
break;
|
||||
}
|
||||
left = argval;
|
||||
if (inexpr2(nospace()) != sp_cst4)
|
||||
syntax("term expected");
|
||||
if (c == '+')
|
||||
argval += left;
|
||||
else
|
||||
argval = left - argval;
|
||||
}
|
||||
return(sp_cst4);
|
||||
}
|
||||
|
||||
int inexpr2(c) register c; {
|
||||
long left;
|
||||
|
||||
if ((c = inexpr3(c)) != sp_cst4)
|
||||
return(c);
|
||||
for (;;) {
|
||||
c = nospace();
|
||||
if (c != '*' && c != '/' && c != '%') {
|
||||
peekc = c;
|
||||
break;
|
||||
}
|
||||
left = argval;
|
||||
if (inexpr3(nospace()) != sp_cst4)
|
||||
syntax("factor expected");
|
||||
if (c == '*')
|
||||
argval *= left;
|
||||
else if (c == '/')
|
||||
argval = left / argval;
|
||||
else
|
||||
argval = left % argval;
|
||||
}
|
||||
return(sp_cst4);
|
||||
}
|
||||
|
||||
inexpr3(c) register c; {
|
||||
|
||||
if (c == '(') {
|
||||
if (inexpr1(nospace()) != sp_cst4)
|
||||
syntax("expression expected");
|
||||
if (nospace() != ')')
|
||||
syntax("')' expected");
|
||||
return(sp_cst4);
|
||||
}
|
||||
return(innumber(c));
|
||||
}
|
||||
|
||||
int innumber(c) register c; {
|
||||
register char *p;
|
||||
register n;
|
||||
int expsign;
|
||||
static char numstr[MAXSTR];
|
||||
long atol();
|
||||
|
||||
p = numstr;
|
||||
expsign = 0;
|
||||
if (c == '+' || c == '-') {
|
||||
if (c == '-')
|
||||
*p++ = c;
|
||||
c = nextchar();
|
||||
}
|
||||
if (isdigit(c) == 0)
|
||||
syntax("digit expected");
|
||||
n = sp_cst4;
|
||||
for (;;) {
|
||||
if (p >= &numstr[MAXSTR-1])
|
||||
fatal("number too long");
|
||||
*p++ = c;
|
||||
c = nextchar();
|
||||
if (c == '.' || c == 'e' || c == 'E') {
|
||||
expsign = c != '.';
|
||||
n = sp_fcon;
|
||||
continue;
|
||||
}
|
||||
if (expsign) {
|
||||
expsign = 0;
|
||||
if (c == '+' || c == '-')
|
||||
continue;
|
||||
}
|
||||
if (isdigit(c) == 0)
|
||||
break;
|
||||
}
|
||||
peekc = c;
|
||||
*p = '\0';
|
||||
c = nospace();
|
||||
if (n == sp_fcon && c != 'F')
|
||||
syntax("'F' expected");
|
||||
if (c == 'I' || c == 'U' || c == 'F')
|
||||
return(incon(numstr,c));
|
||||
peekc = c;
|
||||
argval = atol(numstr);
|
||||
return(sp_cst4);
|
||||
}
|
||||
|
||||
in15u() {
|
||||
|
||||
if (innumber(nextchar()) != sp_cst4)
|
||||
syntax("integer expected");
|
||||
check((argval & ~077777) == 0);
|
||||
}
|
||||
|
||||
int incon(p,c) register char *p; {
|
||||
register char *q;
|
||||
|
||||
q = string;
|
||||
while (*q++ = *p++)
|
||||
;
|
||||
strsiz = q - string - 1;
|
||||
gettyp(cst_ptyp);
|
||||
return(c == 'I' ? sp_icon : (c == 'U' ? sp_ucon : sp_fcon));
|
||||
}
|
||||
|
||||
int instring(termc) {
|
||||
register char *p;
|
||||
register c;
|
||||
|
||||
p = string;
|
||||
for (;;) {
|
||||
c = nextchar();
|
||||
if (c == '\n' || c == EOF) {
|
||||
peekc = c;
|
||||
syntax("non-terminated string");
|
||||
}
|
||||
if (c == termc) {
|
||||
if (termc == '"')
|
||||
*p++ = '\0';
|
||||
break;
|
||||
}
|
||||
if (c == '\\')
|
||||
c = inescape();
|
||||
if (p >= &string[MAXSTR-1])
|
||||
fatal("string too long");
|
||||
*p++ = c;
|
||||
}
|
||||
strsiz = p - string;
|
||||
return(sp_scon);
|
||||
}
|
||||
|
||||
int inescape() {
|
||||
register c,j,r;
|
||||
|
||||
c = nextchar();
|
||||
if (c >= '0' && c <= '7') {
|
||||
r = c - '0';
|
||||
for (j = 0; j < 2; j++) {
|
||||
c = nextchar();
|
||||
if (c < '0' || c > '7') {
|
||||
peekc = c;
|
||||
return(r);
|
||||
}
|
||||
r <<= 3;
|
||||
r += (c - '0');
|
||||
}
|
||||
return(r);
|
||||
}
|
||||
switch (c) {
|
||||
case 'b': return('\b');
|
||||
case 'f': return('\f');
|
||||
case 'n': return('\n');
|
||||
case 'r': return('\r');
|
||||
case 't': return('\t');
|
||||
}
|
||||
return(c);
|
||||
}
|
||||
|
||||
int nospace() {
|
||||
register c;
|
||||
|
||||
do
|
||||
c = nextchar();
|
||||
while (isspace(c) && c != '\n');
|
||||
if (c == ';')
|
||||
do
|
||||
c = nextchar();
|
||||
while (c != '\n' && c != EOF);
|
||||
return(c);
|
||||
}
|
||||
|
||||
int nextchar() {
|
||||
register c;
|
||||
|
||||
if (peekc != EMPTY) {
|
||||
c = peekc;
|
||||
peekc = EMPTY;
|
||||
return(c);
|
||||
}
|
||||
c = getchar();
|
||||
if (isascii(c) == 0 && c != EOF)
|
||||
fatal("non-ascii char");
|
||||
return(c);
|
||||
}
|
||||
|
||||
line_line() {
|
||||
register char *p,*q;
|
||||
static char filebuff[MAXSTR+1];
|
||||
|
||||
gettyp(ptyp(sp_cst2));
|
||||
lineno = (int) (argval-1);
|
||||
gettyp(ptyp(sp_scon));
|
||||
p = string;
|
||||
q = filebuff;
|
||||
while (--strsiz >= 0)
|
||||
*q++ = *p++;
|
||||
*q = '\0';
|
||||
filename = filebuff;
|
||||
}
|
||||
|
||||
init() {
|
||||
register i;
|
||||
|
||||
for (i = sp_fmnem; i <= sp_lmnem; i++)
|
||||
pre_hash(i,em_mnem[i - sp_fmnem]);
|
||||
for (i = sp_fpseu; i <= sp_lpseu; i++)
|
||||
pre_hash(i,em_pseu[i - sp_fpseu]);
|
||||
/* treat '_' as letter */
|
||||
/* In System III the array is called _ctype[] without the trailing '_' */
|
||||
(_ctype_+1)['_'] = (_ctype_+1)['a'];
|
||||
}
|
||||
|
||||
pre_hash(i,s) char *s; {
|
||||
register unsigned h;
|
||||
|
||||
assert(i != 0);
|
||||
h = hash(s);
|
||||
for (;;) {
|
||||
h++;
|
||||
h %= HSIZE;
|
||||
if (hashtab[h] == 0) {
|
||||
hashtab[h] = i;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int hash(s) register char *s; {
|
||||
register h;
|
||||
|
||||
h = 0;
|
||||
while (*s) {
|
||||
h <<= 1;
|
||||
h += *s++;
|
||||
}
|
||||
return(h);
|
||||
}
|
||||
|
||||
/* ----- output ----- */
|
||||
|
||||
putarg(sp) register sp; {
|
||||
register i;
|
||||
|
||||
switch (sp) {
|
||||
case sp_ilb2:
|
||||
i = (int) argval;
|
||||
if (fit8u(i)) {
|
||||
put8(sp_ilb1);
|
||||
put8(i);
|
||||
break;
|
||||
}
|
||||
put8(sp);
|
||||
put16(i);
|
||||
break;
|
||||
case sp_dlb2:
|
||||
i = dlbval;
|
||||
if (fit8u(i)) {
|
||||
put8(sp_dlb1);
|
||||
put8(i);
|
||||
break;
|
||||
}
|
||||
put8(sp);
|
||||
put16(i);
|
||||
break;
|
||||
case sp_cst2:
|
||||
case sp_cst4:
|
||||
if (fit16i(argval) == 0) {
|
||||
put8(sp_cst4);
|
||||
put32(argval);
|
||||
break;
|
||||
}
|
||||
i = (int) argval;
|
||||
if (i >= -sp_zcst0 && i < sp_ncst0 - sp_zcst0) {
|
||||
put8(i + sp_zcst0 + sp_fcst0);
|
||||
break;
|
||||
}
|
||||
put8(sp_cst2);
|
||||
put16(i);
|
||||
break;
|
||||
case sp_doff:
|
||||
put8(sp);
|
||||
putarg(offtyp);
|
||||
putarg(sp_cst4);
|
||||
break;
|
||||
case sp_dnam:
|
||||
case sp_pnam:
|
||||
case sp_scon:
|
||||
put8(sp);
|
||||
putstr();
|
||||
break;
|
||||
case sp_icon:
|
||||
case sp_ucon:
|
||||
case sp_fcon:
|
||||
put8(sp);
|
||||
putarg(sp_cst4);
|
||||
putstr();
|
||||
break;
|
||||
case sp_cend:
|
||||
put8(sp);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
putstr() {
|
||||
register char *p;
|
||||
long consiz;
|
||||
|
||||
consiz = argval;
|
||||
argval = strsiz;
|
||||
putarg(sp_cst4);
|
||||
argval = consiz;
|
||||
p = string;
|
||||
while (--strsiz >= 0)
|
||||
put8(*p++);
|
||||
}
|
||||
|
||||
put16(w) int w; {
|
||||
|
||||
put8(w);
|
||||
put8(w >> 8);
|
||||
}
|
||||
|
||||
put32(f) long f; {
|
||||
|
||||
put16((int) f);
|
||||
put16((int)(f >> 16));
|
||||
}
|
||||
|
||||
/* ----- error handling ----- */
|
||||
|
||||
fail_check() {
|
||||
error("argument range error");
|
||||
}
|
||||
|
||||
/* VARARGS */
|
||||
error(s,a1,a2,a3,a4) char *s; {
|
||||
fprintf(stderr,"%s: line %d: ", filename, lineno);
|
||||
fprintf(stderr,s,a1,a2,a3,a4);
|
||||
fprintf(stderr,"\n");
|
||||
errors++;
|
||||
}
|
||||
|
||||
/* VARARGS */
|
||||
fatal(s,a1,a2,a3,a4) char *s; {
|
||||
error(s,a1,a2,a3,a4);
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
/* VARARGS */
|
||||
syntax(s,a1,a2,a3,a4) char *s; {
|
||||
register c;
|
||||
|
||||
error(s,a1,a2,a3,a4);
|
||||
do
|
||||
c = nextchar();
|
||||
while (c != '\n' && c != EOF);
|
||||
longjmp(recover);
|
||||
}
|
||||
Reference in New Issue
Block a user