void md(int argc, char * argv[])
{
int addr;
int * p;
int i = 0;
int j = 0;
puts("md usage: md 0x0\n");
addr = atoi(argv[1]);
p = (int *)addr;
for (i = 0; i < 16; i++)
{
putx(addr + i*16);
puts(": ");
for (j = 0; j < 4; j++)
{
putx(*p++);
puts(" ");
}
puts("\n");
}
}
void load(int argc, char * argv[])
{
int size = 180;
int addr = 0x51000000;
char * p;
int i;
puts("load usage: load 0x51000000 size\n");
if (argc > 2)
{
addr = atoi(argv[1]);
size = atoi(argv[2]);
}
puts("Ready for binary download to 0x");
putx(addr);
puts(" at 115200 bps...\n");
// get user load addr
p = (char *)addr;
for (i = 0; i < size; i++)
{
*p++ = uart_getchar();
}
puts("load to addr 0x");
putx(addr);
puts("\ntotal size 0x");
putx(size);
puts("\nload finished \n");
}
int main(void) {
const int max = 3;
fori(max) {
forj(max) {
printf("(%d, %d) ", i, j);
}
printf("\n");
}
printf("\n");
some_func(max);
printf("\n");
const int i = 10;
const float f = 1.0f;
putl(i);
putd(f);
putl(10); // still works, sort of...
putx(i);
putx(f);
print_vec2(vec(1.0, 2.0));
print_vec3(vec(1.0, 2.0, 3.0));
struct player p1 = player("Mario");
struct player p2 = player("Luigi", .lives = 2); // -Winitializer-overrides warning
print_player(p1);
print_player(p2);
}
LOCAL NODE *
putpower(bigptr p)
{
NODE *p3;
bigptr base;
struct bigblock *t1, *t2;
ftnint k = 0; /* XXX gcc */
int type;
if(!ISICON(p->b_expr.rightp) ||
(k = p->b_expr.rightp->b_const.fconst.ci)<2)
fatal("putpower: bad call");
base = p->b_expr.leftp;
type = base->vtype;
t1 = fmktemp(type, NULL);
t2 = NULL;
p3 = putassign(cpexpr(t1), cpexpr(base) );
sendp2(p3);
for( ; (k&1)==0 && k>2 ; k>>=1 ) {
p3 = putassign(cpexpr(t1),
mkexpr(OPSTAR, cpexpr(t1), cpexpr(t1)));
sendp2(p3);
}
if(k == 2)
p3 = putx(mkexpr(OPSTAR, cpexpr(t1), cpexpr(t1)));
else {
t2 = fmktemp(type, NULL);
p3 = putassign(cpexpr(t2), cpexpr(t1));
sendp2(p3);
for(k>>=1 ; k>1 ; k>>=1) {
p3 = putassign(cpexpr(t1),
mkexpr(OPSTAR, cpexpr(t1), cpexpr(t1)));
sendp2(p3);
if(k & 1) {
p3 = putassign(cpexpr(t2),
mkexpr(OPSTAR, cpexpr(t2), cpexpr(t1)));
sendp2(p3);
}
}
p3 = putx( mkexpr(OPSTAR, cpexpr(t2),
mkexpr(OPSTAR, cpexpr(t1), cpexpr(t1)) ));
}
frexpr(t1);
if(t2)
frexpr(t2);
frexpr(p);
return p3;
}
VOID putx(
ULONG x
)
/*++
Routine Description:
Writes hex long to the display at the current cursor position.
Arguments:
x - ulong to write.
Returns:
Nothing
--*/
{
ULONG j;
if (x/16)
putx(x/16);
if((j=x%16) > 9) {
putc((char)(j+'A'- 10));
} else {
putc((char)(j+'0'));
}
}
putexpr(expptr p)
#endif
{
/* Write the expression to the p1 file */
p = (expptr) putx (fixtype (p));
p1_expr (p);
}
void
result(IORBH *iorb)
{
puts("\tIORB Status ");
putx(iorb->Status);
puts(", ErrorCode ");
putx(iorb->ErrorCode);
if (iorb->Status & IORB_STATUSBLOCK_AVAIL) {
puts("\n\t status:");
dump((farptr)&status, SizeofStatus);
if (status.sense_len && status.sense_ptr) {
puts("\n\t sense:");
dump(status.sense_ptr, 18);
}
}
putc('\n');
}
void main() {
for (__PINION_memory_map_index i = 0;; i++) {
struct __PINION_memory_map_region region =
__PINION_memory_map_read(i);
putx(region.base);
puts(" ");
putx(region.limit);
puts("\n");
if (region.base == 0 && region.limit == 0) {
break;
}
}
for(;;);
}
void
dump(byte _far *p, int n)
{
int i;
for (i = 0; i < n; ++i) {
putc(' ');
putx(p[i]);
}
}
static void put_sep(proc_entry *t, proc_entry *s, int level){
unsigned int i;
int isfirst = 0;
int islast = 0;
/* last */
for (i = t->childs.len - 1; i >= 0; --i){
if (t->childs.s[i]->count == 0) continue;
if (t->childs.s[i] == s) {islast = 1; break;}
break;
}
/* first */
for(i = 0; i < t->childs.len; ++i){
if (!t->childs.s[i]->count) continue;
if (t->childs.s[i] == s) {isfirst = 1; break;}
break;
}
if (isfirst){
if (islast){
put_str("---");
return;
}
else{
put_str("-");putx("+");put_str("-");
return;
}
}
put_newline(t);
if (islast){
put_str("`-");
return;
}
else{
putx("|");put_str("-");
return;
}
}
/*
* Put return values into correct register.
*/
void
putforce(int t, bigptr p)
{
NODE *p1;
p = mkconv(t, fixtype(p));
p1 = putx(p);
p1 = mkunode(FORCE, p1, 0,
(t==TYSHORT ? SHORT : (t==TYLONG ? LONG : LDOUBLE)));
sendp2(p1);
}
dim_finish(Namep v)
#endif
{
register struct Dimblock *p;
register expptr q;
register int i, nd;
p = v->vdim;
v->vdimfinish = 0;
nd = p->ndim;
doin_setbound = 1;
for(i = 0; i < nd; i++)
if (q = p->dims[i].dimexpr) {
q = p->dims[i].dimexpr = make_int_expr(putx(fixtype(q)));
if (!ONEOF(q->headblock.vtype, MSKINT|MSKREAL))
bad_dimtype(v);
}
if (q = p->basexpr)
p->basexpr = make_int_expr(putx(fixtype(q)));
doin_setbound = 0;
}
void init_uhci(uint16_t basePort)
{
_base=basePort;
UHCIStatusReg stat;
stat.status_word= inw(_base+UHCI_USBSTS);
puts(" USB STATUS: ");
putx(stat.status_word);
puts("\n");
}
LOCAL NODE *
putcat(bigptr lhs, bigptr rhs)
{
NODE *p3;
int n;
struct bigblock *lp, *cp;
n = ncat(rhs);
lp = mktmpn(n, TYLENG, NULL);
cp = mktmpn(n, TYADDR, NULL);
n = 0;
putct1(rhs, lp, cp, &n);
p3 = putx( call4(TYSUBR, "s_cat", lhs, cp, lp, MKICON(n) ) );
return p3;
}
make_param(register struct Paramblock *p, expptr e)
#endif
{
register expptr q;
struct Constblock qc;
p->vclass = CLPARAM;
impldcl((Namep)p);
if (e->headblock.vtype != TYCHAR)
e = putx(fixtype(e));
p->paramval = q = mkconv(p->vtype, e);
if (p->vtype == TYCHAR) {
if (q->tag == TEXPR)
p->paramval = q = fixexpr((Exprp)q);
if (q->tag == TADDR && q->addrblock.uname_tag == UNAM_CONST) {
qc.Const = q->addrblock.user.Const;
qc.tag = TCONST;
qc.vtype = q->addrblock.vtype;
qc.vleng = q->addrblock.vleng;
q = (expptr)&qc;
}
if (!ISCONST(q) || q->constblock.vtype != TYCHAR) {
errstr("invalid value for character parameter %s",
p->fvarname);
return;
}
if (!(e = p->vleng))
p->vleng = ICON(q->constblock.vleng->constblock.Const.ci
+ q->constblock.Const.ccp1.blanks);
else if (q->constblock.vleng->constblock.Const.ci
> e->constblock.Const.ci) {
q->constblock.vleng->constblock.Const.ci
= e->constblock.Const.ci;
q->constblock.Const.ccp1.blanks = 0;
}
else
q->constblock.Const.ccp1.blanks
= e->constblock.Const.ci
- q->constblock.vleng->constblock.Const.ci;
}
}
/*
* Assign a character to another.
*/
LOCAL NODE *
putcheq(struct bigblock *p)
{
NODE *p1, *p2, *p3;
if( p->b_expr.rightp->tag==TEXPR &&
p->b_expr.rightp->b_expr.opcode==OPCONCAT )
p3 = putcat(p->b_expr.leftp, p->b_expr.rightp);
else if( ISONE(p->b_expr.leftp->vleng) &&
ISONE(p->b_expr.rightp->vleng) ) {
p1 = putaddr( putch1(p->b_expr.leftp) , YES );
p2 = putaddr( putch1(p->b_expr.rightp) , YES );
p3 = mkbinode(ASSIGN, p1, p2, CHAR);
} else
p3 = putx(call2(TYINT, "s_copy",
p->b_expr.leftp, p->b_expr.rightp));
frexpr(p->vleng);
ckfree(p);
return p3;
}
LOCAL NODE *
putcxcmp(struct bigblock *p)
{
NODE *p1;
int opcode;
struct bigblock *lp, *rp;
struct bigblock *q;
opcode = p->b_expr.opcode;
lp = putcx1(p->b_expr.leftp);
rp = putcx1(p->b_expr.rightp);
q = mkexpr( opcode==OPEQ ? OPAND : OPOR ,
mkexpr(opcode, realpart(lp), realpart(rp)),
mkexpr(opcode, imagpart(lp), imagpart(rp)) );
p1 = putx( fixexpr(q) );
ckfree(lp);
ckfree(rp);
ckfree(p);
return p1;
}
void main( void ) {
int i, j;
int fd;
int c;
int *data;
int sectorStart;
Status status;
fputs(SIO_FD, "Where would you like to start writing?\r\n");
sectorStart= readInt(SIO_FD);
status = fopen(sectorStart,1,&fd);
fputs(SIO_FD, "\r\n");
if( status != SUCCESS ) {
puts("open failed!\r\n");
fclose(fd);
exit();
}
puts("Fd value:");
putx((Uint32)fd);
puts("\n");
while(1){
status = read(SIO_FD, &c );
status = write(fd, c);
if (c == 0x04) break; //wait for EOT
if( status != SUCCESS ) {
puts( "writer: write failed\n");
break;
}
status = write(SIO_FD, c);
}
fclose(fd);
puts("===File closed===\r\n");
}
void lclcmd(int ch)
{
if (ch == 'd') /* dump memory */
{
putx(' ');
if (gethex())
{
unsigned char *p;
p = (unsigned char *) (int) val;
if (gethex())
{
newline();
prtbuf(p,val);
}
}
}
#if DBGMSG
else if (ch == 'D') /* dump dbg buffer */
{
newline();
int empty = dbgemp;
for (int i = 0; i < dbgcnt; i++)
{
P_DBGMSG p = &dbgdata[empty];
float t = (float) p->time / 1000;
printf("%8.3f %8s %8x %12d\n", t, p->str,
(unsigned int) p->val, (int) p->val);
empty++;
if (empty >= MAXDBGMSG)
empty = 0;
while (1)
{
if (pollBufChar() == 0)
break;
}
}
printf("z %d x %d\n", zLoc, xLoc);
}
else if (ch == 'E') /* clear debug buffer */
{
clrDbgBuf();
}
#endif
#if ENCTEST
else if (ch == 'e')
{
printf(" counts ");
fflush(stdout);
if (getnum())
{
encInit();
encRunCount = val;
encStart(true);
}
else
{
printf(" stop[y] ");
fflush(stdout);
ch = getx();
if (ch == 'y')
{
encStop();
}
}
}
#endif
else if (ch == 't')
{
putx(' ');
if (getnum())
{
newline();
int i;
int j = 0;
for (i = 0; i < val; i++)
{
LOAD(XLDZCTL, j);
read1(XRDZCTL);
int testVal = j & ((1 << (zCtl_size)) - 1);
if (readval.i != testVal)
{
setSync();
printf("%4d z testVal %8x readVal %8x\n",
i, (unsigned int) testVal, (unsigned int) readval.i);
clrSync();
}
LOAD(XLDXCTL, j);
read1(XRDXCTL);
testVal = j & ((1 << (xCtl_size)) - 1);
if (readval.i != testVal)
{
setSync();
printf("%4d x testVal %8x readVal %8x\n",
i, (unsigned int) testVal, (unsigned int) readval.i);
clrSync();
}
j += 1;
while (pollBufChar() != 0)
;
}
}
}
else if (ch == 'q')
{
gpioInfo(GPIOA);
usartInfo(USART1);
usartInfo(USART2);
usartInfo(USART6);
putstr1("start remcmd\n");
}
else if (ch == 'r') /* read memory */
{
putx(' ');
if (gethex())
{
printf("%x",*(int16_t *) (int) val);
}
}
else if (ch == 'w') /* write memory */
{
putx(' ');
if (gethex())
{
int16_t *p;
p = (int16_t *) (int) val;
printf(" %x ",*p);
if (gethex())
{
*p = val;
}
}
}
else if (ch == 'a') /* set command address */
{
putx(' ');
if (getnum())
addr = val;
}
else if (ch == 'g') /* read spi data */
{
putx(' ');
if (getnum())
{
addr = val; /* save address */
read1(addr); /* read from device */
printf("\nread addr %x val %8lx %10ld",addr,readval.i,readval.i);
}
}
else if (ch == 'G') /* read spi repeatedly */
{
putx(' ');
if (getnum()) /* enter address */
{
addr = val; /* save address */
putx(' ');
if (getnum()) /* enter number of tries */
{
newline();
int16_t i = (int16_t) val;
while (1)
{
read1(addr); /* read from device */
if (chRdy()) /* if character available */
{
ch = chRead();
break;
}
if ((i != 0)
&& (--i <= 0))
break;
}
printf("spiw0 %d spiw1 %d",spiw0,spiw1);
}
}
}
else if (ch == 's') /* send val to address a */
{
printf(" addr ");
fflush(stdout);
if (getnum()) /* read address */
{
addr = val;
printf(" data ");
fflush(stdout);
if (getnum()) /* read data */
{
printf("\nsending addr %x %10ld val %8lx",addr,val,val);
LOAD(addr,val);
}
}
}
else if (ch == 'p') /* set print flag */
{
putx(' ');
if (getnum())
{
print = val;
}
}
else if (ch == 'r') /* reset */
{
LOAD(XLDZCTL,0);
LOAD(XLDXCTL,0);
LOAD(XLDTCTL,0);
LOAD(XLDDCTL,0);
}
else if (ch == 'x') /* move x rel */
{
putx(' ');
if (getnum())
{
xMoveRel(val, XMOV);
}
}
else if (ch == 'z') /* move z rel */
{
putx(' ');
if (getnum())
{
zMoveRel(val, XMOV);
}
}
else if (ch == 'u') /* send debug message */
{
putx(' ');
if (getnum())
{
dbgmsg("test",val);
}
}
}
putsteq(Addrp a, Addrp b)
#endif
{
return putx( fixexpr((Exprp)
mkexpr(OPSTAREQ, cpexpr((expptr)a), cpexpr((expptr)b))));
}
putassign(expptr lp, expptr rp)
#endif
{
return putx(fixexpr((Exprp)mkexpr(OPASSIGN, lp, rp)));
}
int nvprintf(size_t size, const char *fmt, va_list ap)
{
u32 i;
return_val_if_fail(fmt != NULL, -1);
for (i = 0; i < size; i++) {
if (fmt[i] == '%') {
if ((i + 1) < size && fmt[i+1] != '%') {
char conv = fmt[i+1];
switch (conv) {
case 'c':
{
char c = va_arg(ap, char);
putchar(c);
i++;
break;
}
case 'u':
{
unsigned int u = va_arg(ap,
unsigned int);
putu(u);
i++;
break;
}
case 'x':
case 'X':
{
unsigned int x = va_arg(ap,
unsigned int);
putx(x);
i++;
break;
}
case 'd':
case 'i':
{
int d = va_arg(ap, int);
putd(d);
i++;
break;
}
case 'p':
{
void *p = va_arg(ap, void *);
putp(p);
i++;
break;
}
case 's':
{
const char *s = va_arg(ap, char *);
puts(s);
i++;
break;
}
}
}
} else {
/* print a pointer */
static void putp(const void *p)
{
putx((unsigned int)p);
}
static NODE *
putaddr(bigptr q, int indir)
{
int type, type2, funct;
NODE *p, *p1, *p2;
ftnint offset;
bigptr offp;
p = p1 = p2 = NULL; /* XXX */
type = q->vtype;
type2 = types2[type];
funct = (q->vclass==CLPROC ? FTN<<TSHIFT : 0);
offp = (q->b_addr.memoffset ? cpexpr(q->b_addr.memoffset) : NULL);
offset = simoffset(&offp);
if(offp)
offp = mkconv(TYINT, offp);
switch(q->vstg) {
case STGAUTO:
if(indir && !offp) {
p = oregtree(offset, AUTOREG, type2);
break;
}
if(!indir && !offp && !offset) {
p = mklnode(REG, 0, AUTOREG, INCREF(type2));
break;
}
p = mklnode(REG, 0, AUTOREG, INCREF(type2));
if(offp) {
p1 = putx(offp);
if(offset)
p2 = mklnode(ICON, offset, 0, INT);
} else
p1 = mklnode(ICON, offset, 0, INT);
if (offp && offset)
p1 = mkbinode(PLUS, p1, p2, INCREF(type2));
p = mkbinode(PLUS, p, p1, INCREF(type2));
if (indir)
p = mkunode(UMUL, p, 0, type2);
break;
case STGARG:
p = oregtree(ARGOFFSET + (ftnint)(q->b_addr.memno),
ARGREG, INCREF(type2)|funct);
if (offp)
p1 = putx(offp);
if (offset)
p2 = mklnode(ICON, offset, 0, INT);
if (offp && offset)
p1 = mkbinode(PLUS, p1, p2, INCREF(type2));
else if (offset)
p1 = p2;
if (offp || offset)
p = mkbinode(PLUS, p, p1, INCREF(type2));
if (indir)
p = mkunode(UMUL, p, 0, type2);
break;
case STGLENG:
if(indir) {
p = oregtree(ARGOFFSET + (ftnint)(q->b_addr.memno),
ARGREG, INCREF(type2)|funct);
} else {
fatal1("faddrnode: STGLENG: fixme!");
#if 0
p2op(P2PLUS, types2[TYLENG] | P2PTR );
p2reg(ARGREG, types2[TYLENG] | P2PTR );
p2icon( ARGOFFSET +
(ftnint) (FUDGEOFFSET*p->b_addr.memno), P2INT);
#endif
}
break;
case STGBSS:
case STGINIT:
case STGEXT:
case STGCOMMON:
case STGEQUIV:
case STGCONST:
if(offp) {
p1 = putx(offp);
p2 = putmem(q, ICON, offset);
p = mkbinode(PLUS, p1, p2, INCREF(type2));
if(indir)
p = mkunode(UMUL, p, 0, type2);
} else
p = putmem(q, (indir ? NAME : ICON), offset);
break;
case STGREG:
if(indir)
p = mklnode(REG, 0, q->b_addr.memno, type2);
else
fatal("attempt to take address of a register");
break;
default:
fatal1("putaddr: invalid vstg %d", q->vstg);
}
frexpr(q);
return p;
}
static NODE *
putassign(bigptr lp, bigptr rp)
{
return putx(fixexpr(mkexpr(OPASSIGN, lp, rp)));
}
//
// standard printf function with a subset of formating features supported.
//
// supported
// %d, %ld - signed short, signed long
// %u, %lu - unsigned short, unsigned long
// %c, %s - character, string
// %x, %lx - unsigned print in hex, unsigned long print in hex
// %wS,%wZ - unicode string
//
// does not do:
//
// - field width specification
// - floating point.
//
VOID BlPrint(__in PCHAR cp,...)
{
PVOID ap = Add2Ptr(&cp,sizeof(PCHAR),PVOID);
USHORT b = 0;
ULONG Count = 0;
ULONG DeviceId = BlConsoleOutDeviceId ? BlConsoleOutDeviceId : 1;
while(b = *cp ++)
{
if(b == '%')
{
USHORT c = *cp ++;
switch(c)
{
case 'c':
ArcWrite(DeviceId,ap,sizeof(UCHAR),&Count);
ap = Add2Ptr(ap,sizeof(LONG),PVOID);
break;
case 'd':
puti(*static_cast<PLONG>(ap));
ap = Add2Ptr(ap,sizeof(LONG),PVOID);
break;
case 'l':
{
USHORT d = *cp ++;
switch(d)
{
case 'd':
puti(*static_cast<PLONG>(ap));
ap = Add2Ptr(ap,sizeof(LONG),PVOID);
break;
case 'u':
putu(*static_cast<PUSHORT>(ap));
ap = Add2Ptr(ap,sizeof(LONG),PVOID);
break;
case 'x':
{
ULONG x = *static_cast<PULONG>(ap);
ULONG ZeroLength = (x < 0x10) + (x < 0x100) + (x < 0x1000) + (x < 0x10000) + (x < 0x100000) + (x < 0x1000000) + (x < 0x10000000);
while(ZeroLength --)
ArcWrite(DeviceId,"0",sizeof(UCHAR),&Count);
putx(x);
ap = Add2Ptr(ap,sizeof(LONG),PVOID);
}
break;
}
}
break;
case 's':
{
PCHAR String = *static_cast<PCHAR*>(ap);
ArcWrite(DeviceId,String,strlen(String),&Count);
ap = Add2Ptr(ap,sizeof(PCHAR),PVOID);
}
break;
case 'u':
putu(*static_cast<PUSHORT>(ap));
ap = Add2Ptr(ap,sizeof(LONG),PVOID);
break;
case 'w':
{
USHORT d = *cp ++;
switch(d)
{
case 'S':
case 'W':
putwS(*static_cast<PUNICODE_STRING*>(ap));
ap = Add2Ptr(ap,sizeof(PUNICODE_STRING),PVOID);
break;
}
}
break;
case 'x':
{
USHORT x = *static_cast<PUSHORT>(ap);
ULONG ZeroLength = (x < 0x10) + (x < 0x100) + (x < 0x1000);
while(ZeroLength --)
ArcWrite(DeviceId,"0",sizeof(UCHAR),&Count);
putx(x);
ap = Add2Ptr(ap,sizeof(LONG),PVOID);
}
break;
default:
ArcWrite(DeviceId,&b,sizeof(UCHAR),&Count);
ArcWrite(DeviceId,&c,sizeof(UCHAR),&Count);
break;
}
}
else
{
if(!DbcsLangId || !GrIsDBCSLeadByte(cp[-1]))
{
ArcWrite(DeviceId,cp - 1,1,&Count);
}
else
{
ArcWrite(DeviceId,cp - 1,2,&Count);
cp += 1;
}
}
}
}
VOID
BlPrint(
PCHAR cp,
...
)
/*++
Routine Description:
Standard printf function with a subset of formating features supported.
Currently handles
%d, %ld - signed short, signed long
%u, %lu - unsigned short, unsigned long
%c, %s - character, string
%x, %lx - unsigned print in hex, unsigned long print in hex
Does not do:
- field width specification
- floating point.
Arguments:
cp - pointer to the format string, text string.
Returns:
Nothing
--*/
{
USHORT b,c,w,len;
PUCHAR ap;
ULONG l;
//
// Cast a pointer to the first word on the stack
//
ap = (PUCHAR)&cp + sizeof(PCHAR);
sc = ' '; // default padding char is space
//
// Process the arguments using the descriptor string
//
while (b = *cp++)
{
if (b == '%')
{
c = *cp++;
switch (c)
{
case 'd':
puti((long)*((int *)ap));
ap += sizeof(int);
break;
case 's':
BlPuts(*((PCHAR *)ap));
ap += sizeof (char *);
break;
case 'c':
putc(*((char *)ap));
ap += sizeof(int);
break;
case 'x':
w = *((USHORT *)ap);
len = ZLEN_SHORT(w);
while(len--) putc('0');
putx((ULONG)*((USHORT *)ap));
ap += sizeof(int);
break;
case 'u':
putu((ULONG)*((USHORT *)ap));
ap += sizeof(int);
break;
case 'l':
c = *cp++;
switch(c) {
case 'u':
putu(*((ULONG *)ap));
ap += sizeof(long);
break;
case 'x':
l = *((ULONG *)ap);
len = ZLEN_LONG(l);
while(len--) putc('0');
putx(*((ULONG *)ap));
ap += sizeof(long);
break;
case 'd':
puti(*((ULONG *)ap));
ap += sizeof(long);
break;
}
break;
default :
putc((char)b);
putc((char)c);
}
}
else
putc((char)b);
}
}
/*
* Convert a f77 tree statement to something that looks like a
* pcc expression tree.
*/
NODE *
putx(bigptr q)
{
struct bigblock *x1;
NODE *p = NULL; /* XXX */
int opc;
int type, k;
#ifdef PCC_DEBUG
if (tflag) {
printf("putx %p\n", q);
fprint(q, 0);
}
#endif
switch(q->tag) {
case TERROR:
ckfree(q);
break;
case TCONST:
switch(type = q->vtype) {
case TYLOGICAL:
type = tyint;
case TYLONG:
case TYSHORT:
p = mklnode(ICON, q->b_const.fconst.ci,
0, types2[type]);
ckfree(q);
break;
case TYADDR:
p = mklnode(ICON, 0, 0, types2[type]);
p->n_name = copys(memname(STGCONST,
(int)q->b_const.fconst.ci));
ckfree(q);
break;
default:
p = putx(putconst(q));
break;
}
break;
case TEXPR:
switch(opc = q->b_expr.opcode) {
case OPCALL:
case OPCCALL:
if( ISCOMPLEX(q->vtype) )
p = putcxop(q);
else {
putcall(q);
p = callval;
}
break;
case OPMIN:
case OPMAX:
p = putmnmx(q);
break;
case OPASSIGN:
if (ISCOMPLEX(q->b_expr.leftp->vtype) ||
ISCOMPLEX(q->b_expr.rightp->vtype)) {
frexpr(putcxeq(q));
} else if (ISCHAR(q))
p = putcheq(q);
else
goto putopp;
break;
case OPEQ:
case OPNE:
if (ISCOMPLEX(q->b_expr.leftp->vtype) ||
ISCOMPLEX(q->b_expr.rightp->vtype) ) {
p = putcxcmp(q);
break;
}
case OPLT:
case OPLE:
case OPGT:
case OPGE:
if(ISCHAR(q->b_expr.leftp))
p = putchcmp(q);
else
goto putopp;
break;
case OPPOWER:
p = putpower(q);
break;
case OPSTAR:
/* m * (2**k) -> m<<k */
if (XINT(q->b_expr.leftp->vtype) &&
ISICON(q->b_expr.rightp) &&
((k = flog2(q->b_expr.rightp->b_const.fconst.ci))>0) ) {
q->b_expr.opcode = OPLSHIFT;
frexpr(q->b_expr.rightp);
q->b_expr.rightp = MKICON(k);
goto putopp;
}
case OPMOD:
goto putopp;
case OPPLUS:
case OPMINUS:
case OPSLASH:
case OPNEG:
if( ISCOMPLEX(q->vtype) )
p = putcxop(q);
else
goto putopp;
break;
case OPCONV:
if( ISCOMPLEX(q->vtype) )
p = putcxop(q);
else if (ISCOMPLEX(q->b_expr.leftp->vtype)) {
p = putx(mkconv(q->vtype,
realpart(putcx1(q->b_expr.leftp))));
ckfree(q);
} else
goto putopp;
break;
case OPAND:
/* Create logical AND */
x1 = fmktemp(TYLOGICAL, NULL);
putexpr(mkexpr(OPASSIGN, cpexpr(x1),
mklogcon(0)));
k = newlabel();
putif(q->b_expr.leftp, k);
putif(q->b_expr.rightp, k);
putexpr(mkexpr(OPASSIGN, cpexpr(x1),
mklogcon(1)));
putlabel(k);
p = putx(x1);
break;
case OPNOT: /* Logical NOT */
x1 = fmktemp(TYLOGICAL, NULL);
putexpr(mkexpr(OPASSIGN, cpexpr(x1),
mklogcon(1)));
k = newlabel();
putif(q->b_expr.leftp, k);
putexpr(mkexpr(OPASSIGN, cpexpr(x1),
mklogcon(0)));
putlabel(k);
p = putx(x1);
break;
case OPOR: /* Create logical OR */
x1 = fmktemp(TYLOGICAL, NULL);
putexpr(mkexpr(OPASSIGN, cpexpr(x1),
mklogcon(1)));
k = newlabel();
putif(mkexpr(OPEQ, q->b_expr.leftp,
mklogcon(0)), k);
putif(mkexpr(OPEQ, q->b_expr.rightp,
mklogcon(0)), k);
putexpr(mkexpr(OPASSIGN, cpexpr(x1),
mklogcon(0)));
putlabel(k);
p = putx(x1);
break;
case OPCOMMA:
for (x1 = q; x1->b_expr.opcode == OPCOMMA;
x1 = x1->b_expr.leftp)
putexpr(x1->b_expr.rightp);
p = putx(x1);
break;
case OPEQV:
case OPNEQV:
case OPADDR:
case OPBITOR:
case OPBITAND:
case OPBITXOR:
case OPBITNOT:
case OPLSHIFT:
case OPRSHIFT:
putopp:
p = putop(q);
break;
default:
fatal1("putx: invalid opcode %d", opc);
}
break;
case TADDR:
p = putaddr(q, YES);
break;
default:
fatal1("putx: impossible tag %d", q->tag);
}
return p;
}
LOCAL NODE *
putop(bigptr q)
{
NODE *p;
int k;
bigptr lp, tp;
int pt, lt;
#ifdef PCC_DEBUG
if (tflag) {
printf("putop %p\n", q);
fprint(q, 0);
}
#endif
switch(q->b_expr.opcode) { /* check for special cases and rewrite */
case OPCONV:
pt = q->vtype;
lp = q->b_expr.leftp;
lt = lp->vtype;
while(q->tag==TEXPR && q->b_expr.opcode==OPCONV &&
((ISREAL(pt)&&ISREAL(lt)) ||
(XINT(pt)&&(ONEOF(lt,MSKINT|MSKADDR))) )) {
if(lp->tag != TEXPR) {
if(pt==TYINT && lt==TYLONG)
break;
if(lt==TYINT && pt==TYLONG)
break;
}
ckfree(q);
q = lp;
pt = lt;
lp = q->b_expr.leftp;
lt = lp->vtype;
}
if(q->tag==TEXPR && q->b_expr.opcode==OPCONV)
break;
p = putx(q);
return p;
case OPADDR:
lp = q->b_expr.leftp;
if(lp->tag != TADDR) {
tp = fmktemp(lp->vtype, lp->vleng);
p = putx(mkexpr(OPASSIGN, cpexpr(tp), lp));
sendp2(p);
lp = tp;
}
p = putaddr(lp, NO);
ckfree(q);
return p;
}
if ((k = ops2[q->b_expr.opcode]) <= 0)
fatal1("putop: invalid opcode %d (%d)", q->b_expr.opcode, k);
p = putx(q->b_expr.leftp);
if(q->b_expr.rightp)
p = mkbinode(k, p, putx(q->b_expr.rightp), types2[q->vtype]);
else
p = mkunode(k, p, 0, types2[q->vtype]);
if(q->vleng)
frexpr(q->vleng);
ckfree(q);
return p;
}
void main(void) {
unsigned int pid;
unsigned int status;
shared_object *ptr;
char *local_str1 = "Hello from the parent\n";
char *local_str2 = "Hello from the child\n";
status = fork(&pid);
if (status != SUCCESS) {
/* failure */
puts("shm_test: fork: ");
putx(status);
puts("\n");
exit();
} else if (pid == 0) {
/* child */
msleep(2500);
puts("shm_test: child: good morning\n");
status = shm_open("test", (void**)&ptr);
if (status != SUCCESS) {
puts("shm_test: shm_open: ");
putx(status);
puts("\n");
exit();
}
putx(ptr->x); puts(" "); putx(ptr->y); puts(" "); putx(ptr->z); puts("\n");
puts("shared str1: ");
puts(ptr->str1);
ptr->x++; ptr->y++; ptr->z++;
memcpy(ptr->str2, local_str2, strlen(local_str2) + 1);
status = shm_close("test");
ptr->x++;
exit();
} else {
/* parent */
puts("shm_test: parent: creating shm region \"test\"\n");
status = shm_create("test", 0x4000, SHM_WRITE, (void**)&ptr);
if (status != SUCCESS) {
puts("shm_test: shm_create: ");
putx(status);
puts("\n");
exit();
}
ptr->x = 0x10;
ptr->y = 0x20;
ptr->z = 0x30;
memcpy(ptr->str1, local_str1, strlen(local_str1) + 1);
msleep(5000);
puts("shm_test: parent: good morning\n");
putx(ptr->x); puts(" "); putx(ptr->y); puts(" "); putx(ptr->z); puts("\n");
puts("shared str2: ");
puts(ptr->str2);
exit();
}
}
