#endif
pCodeOp *popCopyGPR2Bit(pCodeOpReg *pc, int bitval);
-
+pCodeOp *popRegFromString(char *str, int size, int offset);
pCodeOp *newpCodeOpWild(int id, pCodeWildBlock *pcwb, pCodeOp *subtype);
pCode *newpCodeWild(int pCodeID, pCodeOp *optional_operand, pCodeOp *optional_label);
ALT_MNEM1A,
ALT_MNEM1B,
ALT_MNEM2,
- ALT_MNEM2A
+ ALT_MNEM2A,
+ ALT_MNEM3
} altPatterns;
static char alt_comment[] = { PCP_COMMENT, 0};
static char alt_mnem1b[] = { PCP_STR, PCP_NUMBER, 0};
static char alt_mnem2[] = { PCP_STR, PCP_STR, PCP_COMMA, PCP_STR, 0};
static char alt_mnem2a[] = { PCP_STR, PCP_WILDVAR, PCP_COMMA, PCP_STR, 0};
+static char alt_mnem3[] = { PCP_STR, PCP_STR, PCP_COMMA, PCP_NUMBER, 0};
static void * cvt_altpat_label(void *pp,pCodeWildBlock *pcwb);
static void * cvt_altpat_comment(void *pp,pCodeWildBlock *pcwb);
static void * cvt_altpat_mnem1b(void *pp,pCodeWildBlock *pcwb);
static void * cvt_altpat_mnem2(void *pp,pCodeWildBlock *pcwb);
static void * cvt_altpat_mnem2a(void *pp,pCodeWildBlock *pcwb);
+static void * cvt_altpat_mnem3(void *pp,pCodeWildBlock *pcwb);
pcPattern altArr[] = {
{ALT_LABEL, alt_label, cvt_altpat_label},
{ALT_COMMENT, alt_comment,cvt_altpat_comment},
+ {ALT_MNEM3, alt_mnem3, cvt_altpat_mnem3},
{ALT_MNEM2A, alt_mnem2a, cvt_altpat_mnem2a},
{ALT_MNEM2, alt_mnem2, cvt_altpat_mnem2},
{ALT_MNEM1B, alt_mnem1b, cvt_altpat_mnem1b},
}
/*-----------------------------------------------------------------*/
+/* cvt_altpat_mnem2 */
+/* */
+/* pp[0] - mnem */
+/* pp[1] - var */
+/* pp[2] - comma */
+/* pp[3] - destination */
/*-----------------------------------------------------------------*/
static void * cvt_altpat_mnem2(void *pp,pCodeWildBlock *pcwb)
{
pCodeInstruction *pci=NULL;
pCodeOp *pcosubtype;
+ if(!pcwb) {
+ fprintf(stderr,"ERROR %s:%d - can't assemble line\n",__FILE__,__LINE__);
+ return NULL;
+ }
+
dest = cvt_extract_destination(&p[3]);
DFPRINTF((stderr,"altpat_mnem2a %s var %d destination %s(%d)\n",
}
+
+/*-----------------------------------------------------------------*/
+/* cvt_altpat_mem3 - convert assembly line type to a pCode */
+/* This rule is for bsf/bcf type instructions */
+/* */
+/* */
+/* pp[0] - mnem */
+/* pp[1] - register */
+/* pp[2] - comma */
+/* pp[3] - number */
+/* */
+/*-----------------------------------------------------------------*/
+static void * cvt_altpat_mnem3(void *pp,pCodeWildBlock *pcwb)
+{
+ parsedPattern *p = pp;
+ int opcode;
+ int dest; // or could be bit position in the register
+
+ pCodeInstruction *pci=NULL;
+ pCodeOp *pcosubtype=NULL;
+
+ dest = cvt_extract_destination(&p[3]);
+
+ DFPRINTF((stderr,"altpat_mnem3 %s var %s bit (%d)\n",
+ p->pct[0].tok.s,
+ p[1].pct[0].tok.s,
+ p[3].pct[0].tok.n));
+
+
+ opcode = getpCode(p->pct[0].tok.s,0);
+ if(opcode < 0) {
+ fprintf(stderr, "Bad mnemonic\n");
+ return NULL;
+ }
+
+
+ if(pic14Mnemonics[opcode]->isBitInst) {
+ //pcosubtype = cvt_extract_status(p[1].pct[0].tok.s, p[3].pct[0].tok.s);
+
+ //if(pcosubtype == NULL) {
+ pcosubtype = newpCodeOpBit(p[1].pct[0].tok.s,p[3].pct[0].tok.n,0);
+ //}
+ } else
+ pcosubtype = newpCodeOp(p[1].pct[0].tok.s,PO_GPR_REGISTER);
+
+ if(pcosubtype == NULL) {
+ fprintf(stderr, "Bad operand\n");
+ return NULL;
+ }
+
+ pci = PCI(newpCode(opcode, pcosubtype));
+
+ if(!pci)
+ fprintf(stderr,"couldn't find mnemonic\n");
+
+ return pci;
+
+}
+
/*-----------------------------------------------------------------*/
/* tokenizeLineNode - Convert a string (of char's) that was parsed */
/* by SDCCpeeph.c into a string of tokens. */
void dump1Token(pCodeTokens tt)
{
-#ifdef PCODE_DEBUG
+
switch(tt) {
case PCT_SPACE:
fprintf(stderr, " space ");
fprintf(stderr, " null ");
}
-#endif
+
}
/* pcode. */
/*-----------------------------------------------------------------*/
-void parseTokens(pCodeWildBlock *pcwb)
+int parseTokens(pCodeWildBlock *pcwb, pCode **pcret)
{
- unsigned i;
pCode *pc;
+ int error = 0;
if(!tokIdx)
- return;
+ return error;
- for(i=0; i<=tokIdx; i++)
- dump1Token(tokArr[i].tt);
#ifdef PCODE_DEBUG
- fputc('\n',stderr);
+ {
+ unsigned i;
+ for(i=0; i<=tokIdx; i++)
+ dump1Token(tokArr[i].tt);
+ fputc('\n',stderr);
+ }
#endif
+
{
int lparsedPatIdx=0;
int lpcpIdx;
//if(curBlock && pc)
//addpCode2pBlock(curBlock, pc);
- addpCode2pBlock(pcwb->pb, pc);
+ if(pc) {
+ if (pcret) {
+ *pcret = pc;
+ return 0; // Only accept one line for now.
+ } else
+ addpCode2pBlock(pcwb->pb, pc);
+ } else
+ error++;
}
j += c;
}
}
-
+ return error;
}
/*-----------------------------------------------------------------*/
//DFPRINTF((stderr,"%s\n",ln->line));
tokenizeLineNode(ln->line);
- parseTokens(pcwb);
+
+ if(parseTokens(pcwb,NULL)) {
+ int i;
+ fprintf(stderr,"ERROR assembling line:\n%s\n",ln->line);
+ fprintf(stderr,"Tokens:\n");
+ for(i=0; i<5; i++)
+ dump1Token(tokArr[i].tt);
+ fputc('\n',stderr);
+ exit (1);
+ }
+ }
+}
+/*-----------------------------------------------------------------*/
+/* */
+/*-----------------------------------------------------------------*/
+pCode *AssembleLine(char *line)
+{
+ pCode *pc=NULL;
+
+ if(!line || !*line) {
+ fprintf(stderr,"WARNING returning NULL in AssembleLine\n");
+ return NULL;
}
+
+ tokenizeLineNode(line);
+
+ if(parseTokens(NULL,&pc))
+ fprintf(stderr, "WARNING: unable to assemble line:\n%s\n",line);
+
+ return pc;
+
}
/*-----------------------------------------------------------------*/
if(!peepBlock->target.wildpCodeOps[index]) {
peepBlock->target.wildpCodeOps[index] = PCI(pcs)->pcop;
- //if(PCI(pcs)->pcop->type == PO_GPR_TEMP)
+ //fprintf(stderr, "first time for wild opcode #%d\n",index);
+ return 1;
} else {
/*
pcs->print(stderr,pcs);
pcd->print(stderr,pcd);
-
fprintf(stderr, "comparing operands of these instructions, result %d\n",
pCodeOpCompare(PCI(pcs)->pcop, peepBlock->target.wildpCodeOps[index])
);
case PO_GPR_TEMP:
case PO_FSR:
//case PO_INDF:
- n = PCOR(PCI(pcs)->pcop)->r->name;
+ //n = PCOR(PCI(pcs)->pcop)->r->name;
+ n = PCI(pcs)->pcop->name;
break;
default:
}
} else if (PCI(pcd)->pcop->type == PO_LITERAL) {
+ /*
+ pcs->print(stderr,pcs);
+ pcd->print(stderr,pcd);
+
+ fprintf(stderr, "comparing literal operands of these instructions, result %d\n",
+ pCodeOpCompare(PCI(pcs)->pcop, PCI(pcd)->pcop));
+ */
return pCodeOpCompare(PCI(pcs)->pcop, PCI(pcd)->pcop);
+ } else {
+ /* FIXME - need an else to check the case when the destination
+ * isn't a wild card */
+ /*
+ fprintf(stderr, "Destination is not wild: operand compare =%d\n",
+ pCodeOpCompare(PCI(pcs)->pcop, PCI(pcd)->pcop));
+ */
+ return pCodeOpCompare(PCI(pcs)->pcop, PCI(pcd)->pcop);
+
}
- /* FIXME - need an else to check the case when the destination
- * isn't a wild card */
} else
/* The pcd has no operand. Lines match if pcs has no operand either*/
return (PCI(pcs)->pcop == NULL);
}
+/*------------------------------------------------------------------*/
+/* pCodeInsertBefore - splice in the pCode chain starting with pc2 */
+/* into the pCode chain containing pc1 */
+/*------------------------------------------------------------------*/
+void pCodeInsertBefore(pCode *pc1, pCode *pc2)
+{
+
+ if(!pc1 || !pc2)
+ return;
+
+ pc2->prev = pc1->prev;
+ if(pc1->prev)
+ pc1->prev->next = pc2;
+
+ pc2->pb = pc1->pb;
+ pc2->next = pc1;
+ pc1->prev = pc2;
+
+}
+
/*-----------------------------------------------------------------*/
/* pCodeOpCopy - copy a pcode operator */
/*-----------------------------------------------------------------*/
PCOI(pcopnew)->index = PCOI(pcop)->index;
PCOI(pcopnew)->offset = PCOI(pcop)->offset;
PCOI(pcopnew)->_const = PCOI(pcop)->_const;
+ PCOI(pcopnew)->_function = PCOI(pcop)->_function;
break;
case PO_LITERAL:
return pcopnew;
break;
+ case PO_GPR_POINTER:
case PO_GPR_REGISTER:
case PO_GPR_TEMP:
case PO_FSR:
if(!pcin && pct) {
DFPRINTF((stderr," partial match... no more code\n"));
- fprintf(stderr," partial match... no more code\n");
matched = 0;
}
if(!pct) {
projects / fw / sdcc / blobdiff