pCodeOpReg pc_indf = {{PO_INDF, "INDF"}, -1, NULL,NULL};
pCodeOpReg pc_fsr = {{PO_FSR, "FSR"}, -1, NULL,NULL};
+static int mnemonics_initialized = 0;
+
+#if 0
//static char *PIC_mnemonics[] = {
static char *scpADDLW = "ADDLW";
static char *scpADDWF = "ADDWF";
static char *scpTRIS = "TRIS";
static char *scpXORLW = "XORLW";
static char *scpXORWF = "XORWF";
+#endif
+
+static hTab *pic14MnemonicsHash = NULL;
+
static pFile *the_pFile = NULL;
int pCodePeepMatchRule(pCode *pc);
+pCodeInstruction pciADDWF = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_ADDWF,
+ "ADDWF",
+ NULL, // operand
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_REGISTER | PCC_Z) // outCond
+};
+
+pCodeInstruction pciADDFW = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_ADDWF,
+ "ADDWF",
+ NULL, // operand
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_W | PCC_Z) // outCond
+};
+
+pCodeInstruction pciADDLW = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_ADDLW,
+ "ADDLW",
+ NULL, // operand
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ PCC_W, // inCond
+ (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
+};
+
+pCodeInstruction pciANDLW = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_ANDLW,
+ "ANDLW",
+ NULL, // operand
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ PCC_W, // inCond
+ (PCC_W | PCC_Z) // outCond
+};
+
+pCodeInstruction pciANDWF = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_ANDWF,
+ "ANDWF",
+ NULL, // operand
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_REGISTER | PCC_Z) // outCond
+};
+
+pCodeInstruction pciANDFW = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_ANDWF,
+ "ANDWF",
+ NULL, // operand
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_W | PCC_Z) // outCond
+};
+
+pCodeInstruction pciBCF = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_BCF,
+ "BCF",
+ NULL, // operand
+ 2, // num ops
+ 0,1, // dest, bit instruction
+ PCC_NONE, // inCond
+ PCC_EXAMINE_PCOP // outCond
+};
+
+pCodeInstruction pciBSF = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_BSF,
+ "BSF",
+ NULL, // operand
+ 2, // num ops
+ 0,1, // dest, bit instruction
+ PCC_NONE, // inCond
+ PCC_EXAMINE_PCOP // outCond
+};
+
+pCodeInstruction pciBTFSC = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ AnalyzeSKIP,
+ genericDestruct,
+ genericPrint},
+ POC_BTFSC,
+ "BTFSC",
+ NULL, // operand
+ 2, // num ops
+ 0,1, // dest, bit instruction
+ PCC_EXAMINE_PCOP, // inCond
+ PCC_NONE // outCond
+};
+
+pCodeInstruction pciBTFSS = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ AnalyzeSKIP,
+ genericDestruct,
+ genericPrint},
+ POC_BTFSS,
+ "BTFSS",
+ NULL, // operand
+ 2, // num ops
+ 0,1, // dest, bit instruction
+ PCC_EXAMINE_PCOP, // inCond
+ PCC_NONE // outCond
+};
+
+pCodeInstruction pciCALL = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_CALL,
+ "CALL",
+ NULL, // operand
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ PCC_NONE, // inCond
+ PCC_NONE // outCond
+};
+
+//fixme - need a COMFW instruction.
+pCodeInstruction pciCOMF = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_COMF,
+ "COMF",
+ NULL, // operand
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ PCC_NONE, // inCond
+ PCC_NONE // outCond
+};
+
+pCodeInstruction pciCLRF = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_CLRF,
+ "CLRF",
+ NULL, // operand
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ PCC_REGISTER, // inCond
+ PCC_REGISTER // outCond
+};
+
+pCodeInstruction pciCLRW = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_CLRW,
+ "CLRW",
+ NULL, // operand
+ 0, // num ops
+ 0,0, // dest, bit instruction
+ PCC_W, // inCond
+ PCC_W // outCond
+};
+
+pCodeInstruction pciDECF = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_DECF,
+ "DECF",
+ NULL, // operand
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ PCC_REGISTER, // inCond
+ PCC_REGISTER // outCond
+};
+
+pCodeInstruction pciDECFW = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_DECFW,
+ "DECF",
+ NULL, // operand
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ PCC_REGISTER, // inCond
+ PCC_W // outCond
+};
+
+pCodeInstruction pciDECFSZ = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ AnalyzeSKIP,
+ genericDestruct,
+ genericPrint},
+ POC_DECFSZ,
+ "DECFSZ",
+ NULL, // operand
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ PCC_REGISTER, // inCond
+ PCC_REGISTER // outCond
+};
+
+pCodeInstruction pciDECFSZW = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ AnalyzeSKIP,
+ genericDestruct,
+ genericPrint},
+ POC_DECFSZW,
+ "DECFSZ",
+ NULL, // operand
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ PCC_REGISTER, // inCond
+ PCC_W // outCond
+};
+
+pCodeInstruction pciGOTO = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ AnalyzeGOTO,
+ genericDestruct,
+ genericPrint},
+ POC_GOTO,
+ "GOTO",
+ NULL, // operand
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ PCC_NONE, // inCond
+ PCC_NONE // outCond
+};
+
+
+pCodeInstruction pciINCF = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_INCF,
+ "INCF",
+ NULL, // operand
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ PCC_REGISTER, // inCond
+ PCC_REGISTER // outCond
+};
+
+pCodeInstruction pciINCFW = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_INCFW,
+ "INCF",
+ NULL, // operand
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ PCC_REGISTER, // inCond
+ PCC_W // outCond
+};
+
+pCodeInstruction pciINCFSZ = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ AnalyzeSKIP,
+ genericDestruct,
+ genericPrint},
+ POC_INCFSZ,
+ "INCFSZ",
+ NULL, // operand
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ PCC_REGISTER, // inCond
+ PCC_REGISTER // outCond
+};
+
+pCodeInstruction pciINCFSZW = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ AnalyzeSKIP,
+ genericDestruct,
+ genericPrint},
+ POC_INCFSZW,
+ "INCFSZ",
+ NULL, // operand
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ PCC_REGISTER, // inCond
+ PCC_W // outCond
+};
+
+pCodeInstruction pciIORWF = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_IORWF,
+ "IORWF",
+ NULL, // operand
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_REGISTER | PCC_Z) // outCond
+};
+
+pCodeInstruction pciIORFW = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_IORWF,
+ "IORWF",
+ NULL, // operand
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_W | PCC_Z) // outCond
+};
+
+pCodeInstruction pciIORLW = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_IORLW,
+ "IORLW",
+ NULL, // operand
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ PCC_W, // inCond
+ (PCC_W | PCC_Z) // outCond
+};
+
+pCodeInstruction pciMOVF = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_MOVF,
+ "MOVF",
+ NULL, // operand
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ PCC_REGISTER, // inCond
+ PCC_Z // outCond
+};
+
+pCodeInstruction pciMOVFW = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_MOVFW,
+ "MOVF",
+ NULL, // operand
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ PCC_REGISTER, // inCond
+ (PCC_W | PCC_Z) // outCond
+};
+
+pCodeInstruction pciMOVWF = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_MOVWF,
+ "MOVWF",
+ NULL, // operand
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ PCC_W, // inCond
+ 0 // outCond
+};
+
+pCodeInstruction pciMOVLW = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_MOVLW,
+ "MOVLW",
+ NULL, // operand
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ PCC_NONE, // inCond
+ PCC_W // outCond
+};
+
+pCodeInstruction pciNEGF = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_NEGF,
+ "NEGF",
+ NULL, // operand
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ PCC_REGISTER, // inCond
+ PCC_NONE // outCond
+};
+
+
+pCodeInstruction pciRETLW = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ AnalyzeRETURN,
+ genericDestruct,
+ genericPrint},
+ POC_RETLW,
+ "RETLW",
+ NULL, // operand
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ PCC_NONE, // inCond
+ PCC_W // outCond
+};
+
+pCodeInstruction pciRETURN = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ AnalyzeRETURN,
+ genericDestruct,
+ genericPrint},
+ POC_RETLW,
+ "RETURN",
+ NULL, // operand
+ 0, // num ops
+ 0,0, // dest, bit instruction
+ PCC_NONE, // inCond
+ PCC_W // outCond
+};
+
+
+pCodeInstruction pciSUBWF = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_SUBWF,
+ "SUBWF",
+ NULL, // operand
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_REGISTER | PCC_Z) // outCond
+};
+
+pCodeInstruction pciSUBFW = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_SUBWF,
+ "SUBWF",
+ NULL, // operand
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_W | PCC_Z) // outCond
+};
+
+pCodeInstruction pciSUBLW = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_SUBLW,
+ "SUBLW",
+ NULL, // operand
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ PCC_W, // inCond
+ (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
+};
+
+pCodeInstruction pciTRIS = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_TRIS,
+ "TRIS",
+ NULL, // operand
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ PCC_NONE, // inCond
+ PCC_NONE
+};
+
+
+pCodeInstruction pciXORWF = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_XORWF,
+ "XORWF",
+ NULL, // operand
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_REGISTER | PCC_Z) // outCond
+};
+
+pCodeInstruction pciXORFW = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_XORWF,
+ "XORWF",
+ NULL, // operand
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_W | PCC_Z) // outCond
+};
+
+pCodeInstruction pciXORLW = {
+ {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL,
+ genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_XORLW,
+ "XORLW",
+ NULL, // operand
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ PCC_W, // inCond
+ (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
+};
+
+
+#define MAX_PIC14MNEMONICS 100
+pCodeInstruction *pic14Mnemonics[MAX_PIC14MNEMONICS];
+
char *Safe_strdup(char *str)
{
char *copy;
}
+/*-----------------------------------------------------------------*/
+/* mnem2key - convert a pic mnemonic into a hash key */
+/* (BTW - this spreads the mnemonics quite well) */
+/* */
+/*-----------------------------------------------------------------*/
+
+int mnem2key(char *mnem)
+{
+ int key = 0;
+
+ if(!mnem)
+ return 0;
+
+ while(*mnem) {
+
+ key += *mnem++ +1;
+
+ }
+
+ return (key & 0x1f);
+
+}
+
+void pic14initMnemonics(void)
+{
+ int i = 0;
+ int key;
+ // char *str;
+ pCodeInstruction *pci;
+
+ if(mnemonics_initialized)
+ return;
+
+ pic14Mnemonics[POC_ADDLW] = &pciADDLW;
+ pic14Mnemonics[POC_ADDWF] = &pciADDWF;
+ pic14Mnemonics[POC_ADDFW] = &pciADDFW;
+ pic14Mnemonics[POC_ANDLW] = &pciANDLW;
+ pic14Mnemonics[POC_ANDWF] = &pciANDWF;
+ pic14Mnemonics[POC_ANDFW] = &pciANDFW;
+ pic14Mnemonics[POC_BCF] = &pciBCF;
+ pic14Mnemonics[POC_BSF] = &pciBSF;
+ pic14Mnemonics[POC_BTFSC] = &pciBTFSC;
+ pic14Mnemonics[POC_BTFSS] = &pciBTFSS;
+ pic14Mnemonics[POC_CALL] = &pciCALL;
+ pic14Mnemonics[POC_COMF] = &pciCOMF;
+ pic14Mnemonics[POC_CLRF] = &pciCLRF;
+ pic14Mnemonics[POC_CLRW] = &pciCLRW;
+ pic14Mnemonics[POC_DECF] = &pciDECF;
+ pic14Mnemonics[POC_DECFW] = &pciDECFW;
+ pic14Mnemonics[POC_DECFSZ] = &pciDECFSZ;
+ pic14Mnemonics[POC_DECFSZW] = &pciDECFSZW;
+ pic14Mnemonics[POC_GOTO] = &pciGOTO;
+ pic14Mnemonics[POC_INCF] = &pciINCF;
+ pic14Mnemonics[POC_INCFW] = &pciINCFW;
+ pic14Mnemonics[POC_INCFSZ] = &pciINCFSZ;
+ pic14Mnemonics[POC_INCFSZW] = &pciINCFSZW;
+ pic14Mnemonics[POC_IORLW] = &pciIORLW;
+ pic14Mnemonics[POC_IORWF] = &pciIORWF;
+ pic14Mnemonics[POC_IORFW] = &pciIORFW;
+ pic14Mnemonics[POC_MOVF] = &pciMOVF;
+ pic14Mnemonics[POC_MOVFW] = &pciMOVFW;
+ pic14Mnemonics[POC_MOVLW] = &pciMOVLW;
+ pic14Mnemonics[POC_MOVWF] = &pciMOVWF;
+ pic14Mnemonics[POC_NEGF] = &pciNEGF;
+ pic14Mnemonics[POC_RETLW] = &pciRETLW;
+ pic14Mnemonics[POC_RETURN] = &pciRETURN;
+ pic14Mnemonics[POC_SUBLW] = &pciSUBLW;
+ pic14Mnemonics[POC_SUBWF] = &pciSUBWF;
+ pic14Mnemonics[POC_SUBFW] = &pciSUBFW;
+ pic14Mnemonics[POC_TRIS] = &pciTRIS;
+ pic14Mnemonics[POC_XORLW] = &pciXORLW;
+ pic14Mnemonics[POC_XORWF] = &pciXORWF;
+ pic14Mnemonics[POC_XORFW] = &pciXORFW;
+
+ for(i=0; i<MAX_PIC14MNEMONICS; i++)
+ if(pic14Mnemonics[i])
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(pic14Mnemonics[i]->mnemonic), pic14Mnemonics[i]);
+/*
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpADDLW), scpADDLW);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpADDWF),scpADDWF);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpANDLW),scpANDLW);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpANDWF),scpANDWF);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpBCF),scpBCF);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpBSF),scpBSF);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpBTFSC),scpBTFSC);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpBTFSS),scpBTFSS);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpCALL),scpCALL);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpCOMF),scpCOMF);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpCLRF),scpCLRF);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpCLRW),scpCLRW);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpDECF),scpDECF);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpDECFSZ),scpDECFSZ);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpGOTO),scpGOTO);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpINCF),scpINCF);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpINCFSZ),scpINCFSZ);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpIORLW),scpIORLW);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpIORWF),scpIORWF);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpMOVF),scpMOVF);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpMOVLW),scpMOVLW);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpMOVWF),scpMOVWF);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpNEGF),scpNEGF);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpRETLW),scpRETLW);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpRETURN),scpRETURN);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpSUBLW),scpSUBLW);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpSUBWF),scpSUBWF);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpTRIS),scpTRIS);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpXORLW),scpXORLW);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(scpXORWF),scpXORWF);
+*/
+
+ pci = hTabFirstItem(pic14MnemonicsHash, &key);
+
+ while(pci) {
+ fprintf( stderr, "element %d key %d, mnem %s\n",i++,key,pci->mnemonic);
+ pci = hTabNextItem(pic14MnemonicsHash, &key);
+ }
+
+ mnemonics_initialized = 1;
+}
+
+
char getpBlock_dbName(pBlock *pb)
{
if(!pb)
printf("pcode is alive!\n");
+ //initMnemonics();
+
if(the_pFile) {
pBlock *pb;
pCode *newpCode (PIC_OPCODE op, pCodeOp *pcop)
{
pCodeInstruction *pci ;
-
+ if(!mnemonics_initialized)
+ pic14initMnemonics();
+
pci = Safe_calloc(1, sizeof(pCodeInstruction));
- pci->pc.analyze = genericAnalyze; // pointers to the generic functions, it
- pci->pc.destruct = genericDestruct; // doesn't hurt to think about C++ virtual
- pci->pc.print = genericPrint; // functions here.
- pci->pc.type = PC_OPCODE; //
- pci->op = op; // the "opcode" for the instruction.
- pci->pc.prev = pci->pc.next = NULL; // The pCode gets linked in later
- pci->pcop = pcop; // The operand of the instruction
- pci->dest = 0; // e.g. W or F
- pci->bit_inst = 0; // e.g. btfxx instructions
- pci->num_ops = 2; // Most instructions have two ops...
- pci->inCond = pci->outCond = PCC_NONE; /* input/output conditions. This is used during
- * optimization to ascertain instruction dependencies.
- * For example, if an instruction affects the Z bit,
- * then the output condition for this instruction
- * is "z bit is affected". The "conditions" are bit
- * constants defined in pcode.h. */
- pci->pc.from = pci->pc.to = NULL; // Flow linkages are defined later
- pci->pc.label = NULL; // Labels get merged into instructions here.
- pci->pc.pb = NULL; // The pBlock to which this instruction belongs
-
- if(pcop && pcop->name)
- printf("newpCode operand name %s\n",pcop->name);
-
- // The most pic dependent portion of the pCode logic:
- switch(op) {
-
- case POC_ANDLW:
- pci->inCond = PCC_W;
- pci->outCond = PCC_W | PCC_Z;
- pci->mnemonic = scpANDLW;
- pci->num_ops = 1;
- break;
- case POC_ANDWF:
- pci->dest = 1;
- pci->inCond = PCC_W | PCC_REGISTER;
- pci->outCond = PCC_REGISTER | PCC_Z;
- pci->mnemonic = scpANDWF;
- break;
- case POC_ANDFW:
- pci->inCond = PCC_W | PCC_REGISTER;
- pci->outCond = PCC_W | PCC_Z;
- pci->mnemonic = scpANDWF;
- break;
+ if((op < MAX_PIC14MNEMONICS) && pic14Mnemonics[op]) {
+ memcpy(pci, pic14Mnemonics[op], sizeof(pCodeInstruction));
+ pci->pcop = pcop;
- case POC_ADDLW:
- pci->inCond = PCC_W;
- pci->outCond = PCC_W | PCC_Z | PCC_C | PCC_DC;
- pci->mnemonic = scpADDLW;
- pci->num_ops = 1;
- break;
- case POC_ADDWF:
- pci->dest = 1;
- pci->inCond = PCC_W | PCC_REGISTER;
- pci->outCond = PCC_REGISTER | PCC_Z | PCC_C | PCC_DC;
- pci->mnemonic = scpADDWF;
- break;
- case POC_ADDFW:
- pci->inCond = PCC_W | PCC_REGISTER;
- pci->outCond = PCC_W | PCC_Z | PCC_C | PCC_DC;
- pci->mnemonic = scpADDWF;
- break;
+ if(pci->inCond == PCC_EXAMINE_PCOP)
+ pci->inCond = RegCond(pcop);
- case POC_BCF:
- pci->bit_inst = 1;
- pci->mnemonic = scpBCF;
- pci->outCond = RegCond(pcop);
- break;
- case POC_BSF:
- pci->bit_inst = 1;
- pci->mnemonic = scpBSF;
- pci->outCond = RegCond(pcop);
- break;
- case POC_BTFSC:
- pci->bit_inst = 1;
- pci->mnemonic = scpBTFSC;
- pci->pc.analyze = AnalyzeSKIP;
- pci->inCond = RegCond(pcop);
- break;
- case POC_BTFSS:
- pci->bit_inst = 1;
- pci->mnemonic = scpBTFSS;
- pci->pc.analyze = AnalyzeSKIP;
- pci->inCond = RegCond(pcop);
- break;
- case POC_CALL:
- pci->num_ops = 1;
- pci->mnemonic = scpCALL;
- break;
- case POC_COMF:
- pci->mnemonic = scpCOMF;
- break;
- case POC_CLRF:
- pci->num_ops = 1;
- pci->mnemonic = scpCLRF;
- break;
- case POC_CLRW:
- pci->num_ops = 0;
- pci->mnemonic = scpCLRW;
- break;
- case POC_DECF:
- pci->dest = 1;
- case POC_DECFW:
- pci->mnemonic = scpDECF;
- break;
- case POC_DECFSZ:
- pci->dest = 1;
- case POC_DECFSZW:
- pci->mnemonic = scpDECFSZ;
- pci->pc.analyze = AnalyzeSKIP;
- break;
- case POC_GOTO:
- pci->num_ops = 1;
- pci->mnemonic = scpGOTO;
- pci->pc.analyze = AnalyzeGOTO;
- break;
- case POC_INCF:
- pci->dest = 1;
- case POC_INCFW:
- pci->mnemonic = scpINCF;
- break;
- case POC_INCFSZ:
- pci->dest = 1;
- case POC_INCFSZW:
- pci->mnemonic = scpINCFSZ;
- pci->pc.analyze = AnalyzeSKIP;
- break;
- case POC_IORLW:
- pci->num_ops = 1;
- pci->mnemonic = scpIORLW;
- break;
- case POC_IORWF:
- pci->dest = 1;
- case POC_IORFW:
- pci->mnemonic = scpIORWF;
- break;
- case POC_MOVF:
- pci->dest = 1;
- case POC_MOVFW:
- pci->mnemonic = scpMOVF;
- break;
- case POC_MOVLW:
- pci->num_ops = 1;
- pci->mnemonic = scpMOVLW;
- break;
- case POC_MOVWF:
- pci->num_ops = 1;
- pci->mnemonic = scpMOVWF;
- break;
- case POC_NEGF:
- pci->mnemonic = scpNEGF;
- break;
- case POC_RETLW:
- pci->num_ops = 1;
- pci->mnemonic = scpRETLW;
- pci->pc.analyze = AnalyzeRETURN;
- break;
- case POC_RETURN:
- pci->num_ops = 0;
- pci->mnemonic = scpRETURN;
- pci->pc.analyze = AnalyzeRETURN;
- break;
- case POC_SUBLW:
- pci->mnemonic = scpSUBLW;
- pci->num_ops = 1;
- break;
- case POC_SUBWF:
- pci->dest = 1;
- case POC_SUBFW:
- pci->mnemonic = scpSUBWF;
- break;
- case POC_TRIS:
- pci->mnemonic = scpTRIS;
- break;
- case POC_XORLW:
- pci->num_ops = 1;
- pci->mnemonic = scpXORLW;
- break;
- case POC_XORWF:
- pci->dest = 1;
- case POC_XORFW:
- pci->mnemonic = scpXORWF;
- break;
+ if(pci->outCond == PCC_EXAMINE_PCOP)
+ pci->outCond = RegCond(pcop);
- default:
- pci->pc.print = genericPrint;
+ return (pCode *)pci;
}
-
- return (pCode *)pci;
+
+ fprintf(stderr, "pCode mnemonic error %s,%d\n",__FUNCTION__,__LINE__);
+ exit(1);
+
+ return NULL;
}
/*-----------------------------------------------------------------*/
-------------------------------------------------------------------------*/
#include <stdio.h>
+#include <stdlib.h>
#include "common.h" // Include everything in the SDCC src directory
#include "newalloc.h"
* defined in peep.def.
*/
-extern peepRule *rootRules;
+//extern peepRule *rootRules;
+
+
/****************************************************************/
static pCodePeepSnippets *peepSnippets=NULL;
+typedef struct pCodeToken
+{
+ int tt; // token type;
+ union {
+ char c; // character
+ int n; // number
+ char *s; // string
+ } tok;
+
+} pCodeToken;
+
+pCodeToken tokArr[50];
+unsigned tokIdx=0;
+
+
+typedef enum {
+ PCT_SPACE,
+ PCT_PERCENT,
+ PCT_COLON,
+ PCT_COMMA,
+ PCT_COMMENT,
+ PCT_STRING,
+ PCT_NUMBER
+
+} pCodeTokens;
+
+
+typedef struct parsedPattern {
+ struct pcPattern *pcp;
+ pCodeToken *pct;
+} parsedPattern;
+
+#define MAX_PARSEDPATARR 50
+parsedPattern parsedPatArr[MAX_PARSEDPATARR];
+unsigned int parsedPatIdx=0;
+
+
+typedef enum {
+ PCP_LABEL,
+ PCP_STR,
+ PCP_WILDVAR,
+ PCP_WILDSTR,
+ PCP_COMMA
+} pCodePatterns;
+
+static char pcpat_label[] = {PCT_PERCENT, PCT_NUMBER, PCT_COLON, 0};
+static char pcpat_string[] = {PCT_STRING, 0};
+static char pcpat_wildString[] = {PCT_PERCENT, PCT_STRING, 0};
+static char pcpat_wildVar[] = {PCT_PERCENT, PCT_NUMBER, 0};
+static char pcpat_comma[] = {PCT_COMMA, 0};
+
+
+typedef struct pcPattern {
+ int pt; // Pattern type
+ char *tokens; // list of tokens that describe the pattern
+ void * (*f) (void *);
+} pcPattern;
+
+pcPattern pcpArr[] = {
+ {PCP_LABEL, pcpat_label, NULL},
+ {PCP_WILDSTR, pcpat_wildString, NULL},
+ {PCP_STR, pcpat_string, NULL},
+ {PCP_WILDVAR, pcpat_wildVar, NULL},
+ {PCP_COMMA, pcpat_comma, NULL}
+};
+
+#define PCPATTERNS (sizeof(pcpArr)/sizeof(pcPattern))
+
+// Assembly Line Token
+typedef enum {
+ ALT_LABEL,
+ ALT_MNEM0,
+ ALT_MNEM1,
+ ALT_MNEM2
+} altPatterns;
+
+static char alt_label[] = { PCP_LABEL, 0};
+static char alt_mnem0[] = { PCP_STR, 0};
+static char alt_mnem1[] = { PCP_STR, PCP_STR, 0};
+static char alt_mnem2[] = { PCP_STR, PCP_STR, PCP_COMMA, PCP_STR, 0};
+
+static void * cvt_altpat_label(void *pp);
+
+pcPattern altArr[] = {
+ {ALT_LABEL, alt_label, cvt_altpat_label},
+ {ALT_MNEM2, alt_mnem2, NULL},
+
+};
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+static void * cvt_altpat_label(void *pp)
+{
+ fprintf(stderr,"altpat_label\n");
+ return NULL;
+}
+
+#if 0
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+static pCode * cvt_pcpat_wildMnem(parsedPattern *pp)
+{
+ fprintf(stderr,"pcpat_wildMnem\n");
+ return NULL;
+}
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+static pCode * cvt_pcpat_Mnem(parsedPattern *pp)
+{
+ fprintf(stderr,"pcpat_Mnem\n");
+ return NULL;
+}
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+static pCode * cvt_pcpat_wildVar(parsedPattern *pp)
+{
+ fprintf(stderr,"pcpat_wildVar\n");
+ return NULL;
+}
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+static pCode * cvt_pcpat_var(parsedPattern *pp)
+{
+ fprintf(stderr,"pcpat_var\n");
+ return NULL;
+}
+#endif
+
+
+
+
+
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+
+
+static void parseLineNode(char *ln)
+{
+
+ tokIdx = 0;
+
+ if(!ln || !*ln)
+ return;
+
+ while(*ln) {
+
+ if(isspace(*ln)) {
+ tokArr[tokIdx++].tt = PCT_SPACE;
+ while (isspace (*ln))
+ ln++;
+ continue;
+ }
+
+ if(isdigit(*ln)) {
+
+ tokArr[tokIdx].tt = PCT_NUMBER;
+ tokArr[tokIdx++].tok.n = strtol(ln, &ln, 10);
+
+ continue;
+
+ }
+
+ switch(*ln) {
+ case '%':
+ tokArr[tokIdx++].tt = PCT_PERCENT;
+ break;
+ case ':':
+ tokArr[tokIdx++].tt = PCT_COLON;
+ break;
+ case ';':
+ tokArr[tokIdx].tok.s = Safe_strdup(ln);
+ tokArr[tokIdx++].tt = PCT_COMMENT;
+ return;
+ case ',':
+ tokArr[tokIdx++].tt = PCT_COMMA;
+ break;
+
+
+ default:
+ if(isalpha(*ln)) {
+ char buffer[50];
+ int i=0;
+
+ while( (isalpha(*ln) || isdigit(*ln)) && i<49)
+ buffer[i++] = *ln++;
+
+ ln--;
+ buffer[i] = 0;
+
+ tokArr[tokIdx].tok.s = Safe_strdup(buffer);
+ //fprintf(stderr," string %s",tokArr[tokIdx].tok.s);
+
+ tokArr[tokIdx++].tt = PCT_STRING;
+
+ }
+ }
+ ln++;
+ }
+}
+
+
+
+
+void dump1Token(pCodeTokens tt)
+{
+
+ switch(tt) {
+ case PCT_SPACE:
+ fprintf(stderr, " space ");
+ break;
+ case PCT_PERCENT:
+ fprintf(stderr, " pct ");
+ fputc('%', stderr);
+ break;
+ case PCT_COLON:
+ fprintf(stderr, " col ");
+ fputc(':',stderr);
+ break;
+ case PCT_COMMA:
+ fprintf(stderr, " com ");
+ fputc(',',stderr);
+ break;
+ case PCT_COMMENT:
+ case PCT_STRING:
+ fprintf(stderr, " str ");
+ //fprintf(stderr,"%s",tokArr[i].tok.s);
+ break;
+ case PCT_NUMBER:
+ fprintf(stderr, " num ");
+ //fprintf(stderr,"%d",tokArr[i].tok.n);
+
+
+ }
+}
+
+
+int pcComparePattern(pCodeToken *pct, char *pat, int max_tokens)
+{
+ int i=0;
+
+ if(!pct || !pat || !*pat)
+ return 0;
+
+ //fprintf(stderr,"comparing against:\n");
+
+ while(i < max_tokens) {
+
+ if(*pat == 0){
+ //fprintf(stderr,"matched\n");
+ return (i+1);
+ }
+
+ //dump1Token(*pat); fprintf(stderr,"\n");
+
+ if(pct->tt != *pat)
+ return 0;
+
+
+ pct++;
+ pat++;
+ }
+
+ return 0;
+
+}
+
+int advTokIdx(int *v, int amt)
+{
+
+ if(*v + amt > tokIdx)
+ return 1;
+
+ *v += amt;
+ return 0;
+
+}
+
+void dumpTokens(void)
+{
+ int i;
+
+ if(!tokIdx)
+ return;
+
+ for(i=0; i<=tokIdx; i++)
+ dump1Token(tokArr[i].tt);
+
+
+ fputc('\n',stderr);
+
+ {
+ int lparsedPatIdx=0;
+ int lpcpIdx;
+ int ltokIdx =0;
+ int matching = 0;
+ int j;
+
+ pCodeOp *pcl = NULL; // Storage for a label
+ pCodeOp *pco1 = NULL; // 1st operand
+ pCodeOp *pco2 = NULL; // 2nd operand
+ pCode *pc = NULL; // Mnemonic
+
+ typedef enum {
+ PS_START,
+ PS_HAVE_LABEL,
+ PS_HAVE_MNEM,
+ PS_HAVE_1OPERAND,
+ PS_HAVE_COMMA,
+ PS_HAVE_2OPERANDS
+ } ParseStates;
+
+ ParseStates state = PS_START;
+
+ do {
+
+ lpcpIdx=0;
+ matching = 0;
+ //fprintf(stderr,"ltokIdx = %d\n",ltokIdx);
+
+ if( ((tokArr[ltokIdx].tt == PCT_SPACE) )//|| (tokArr[ltokIdx].tt == PCT_COMMA))
+ && (advTokIdx(<okIdx, 1)) ) // eat space
+ break;
+
+ do {
+ j = pcComparePattern(&tokArr[ltokIdx], pcpArr[lpcpIdx].tokens, tokIdx +1);
+ if( j ) {
+ //fprintf(stderr,"found token pattern match\n");
+ switch(pcpArr[lpcpIdx].pt) {
+ case PCP_LABEL:
+ if(state == PS_START){
+ fprintf(stderr," label\n");
+ state = PS_HAVE_LABEL;
+ } else
+ fprintf(stderr," bad state (%d) for label\n",state);
+ break;
+
+ case PCP_STR:
+ switch(state) {
+ case PS_START:
+ case PS_HAVE_LABEL:
+ fprintf(stderr," mnem\n");
+ state = PS_HAVE_MNEM;
+ break;
+ case PS_HAVE_MNEM:
+ fprintf(stderr," 1st operand\n");
+ pco1 = newpCodeOp(NULL,PO_GPR_REGISTER);
+ state = PS_HAVE_1OPERAND;
+ break;
+ case PS_HAVE_1OPERAND:
+ fprintf(stderr," error expecting comma\n");
+ break;
+ case PS_HAVE_COMMA:
+ fprintf(stderr," 2 operands\n");
+ break;
+ }
+ break;
+
+ case PCP_WILDVAR:
+ switch(state) {
+ case PS_START:
+ case PS_HAVE_LABEL:
+ fprintf(stderr," wild mnem\n");
+ state = PS_HAVE_MNEM;
+ break;
+ case PS_HAVE_MNEM:
+ fprintf(stderr," 1st operand is wild\n");
+ state = PS_HAVE_1OPERAND;
+ break;
+ case PS_HAVE_1OPERAND:
+ fprintf(stderr," error expecting comma\n");
+ break;
+ case PS_HAVE_COMMA:
+ fprintf(stderr," 2nd operand is wild\n");
+ break;
+ }
+ break;
+
+ case PCP_WILDSTR:
+ break;
+ case PCP_COMMA:
+ if(state == PS_HAVE_1OPERAND){
+ fprintf(stderr," got a comma\n");
+ state = PS_HAVE_COMMA;
+ } else
+ fprintf(stderr," unexpected comma\n");
+ }
+
+ matching = 1;
+ parsedPatArr[lparsedPatIdx].pcp = &pcpArr[lpcpIdx];
+ parsedPatArr[lparsedPatIdx].pct = &tokArr[ltokIdx];
+ lparsedPatIdx++;
+
+ //dump1Token(tokArr[ltokIdx].tt);
+
+ if(advTokIdx(<okIdx, strlen(pcpArr[lpcpIdx].tokens) ) ) {
+ fprintf(stderr," reached end \n");
+ matching = 0;
+ //return;
+ }
+ }
+
+
+ } while ((++lpcpIdx < PCPATTERNS) && !matching);
+
+ } while (matching);
+
+ fprintf(stderr,"\nConverting parsed line to pCode:\n\n");
+
+ j = 0;
+ do {
+ if(parsedPatArr[j].pcp && parsedPatArr[j].pcp->f )
+ parsedPatArr[j].pcp->f(&parsedPatArr[j]);
+ j++;
+ }
+ while(j<lparsedPatIdx);
+
+ fprintf(stderr,"\n");
+
+ }
+ return;
+ /*now decode */
+#if 0
+ i=0;
+
+ if(pcComparePattern(&tokArr[0], pcpat_label, tokIdx +1)) {
+ fprintf(stderr,"has a wild label\n");
+ if(advTokIdx(&i, sizeof(pcpat_label) -1))
+ return;
+ }
+
+ if( (tokArr[i].tt == PCT_SPACE) && (advTokIdx(&i, 1)) ) // eat space
+ return;
+
+ if(pcComparePattern(&tokArr[i], pcpat_wildMnem, tokIdx +1 -i)) {
+ fprintf(stderr,"has a wild mnemonic\n");
+ if(advTokIdx(&i, sizeof(pcpat_wildMnem) -1))
+ return;
+ } else if(pcComparePattern(&tokArr[i], pcpat_Mnem, tokIdx +1 -i)) {
+ fprintf(stderr,"has a mnemonic\n");
+ if(advTokIdx(&i, sizeof(pcpat_Mnem) -1))
+ return;
+ } else
+ return; // doesn't matter what follows
+
+ if( (tokArr[i].tt == PCT_SPACE) && (advTokIdx(&i, 1)) ) // eat space
+ return;
+
+ fprintf(stderr,"checking variable; next token ");
+ dump1Token(tokArr[i].tt);
+ fprintf(stderr,"\n");
+
+ if(pcComparePattern(&tokArr[i], pcpat_wildVar, tokIdx +1 -i)) {
+ fprintf(stderr,"has a wild var\n");
+ if(advTokIdx(&i, sizeof(pcpat_wildVar) -1))
+ return;
+ } else if(pcComparePattern(&tokArr[i], pcpat_Var, tokIdx +1 -i)) {
+ fprintf(stderr,"has a var\n");
+ if(advTokIdx(&i, sizeof(pcpat_Var) -1))
+ return;
+ } else
+ return;
+
+ if( ((tokArr[i].tt == PCT_SPACE) || (tokArr[i].tt == PCT_COMMA))
+ && (advTokIdx(&i, 1)) ) // eat space
+ return;
+
+ if(pcComparePattern(&tokArr[i], pcpat_wildVar, tokIdx +10 -i)) {
+ fprintf(stderr,"has a wild var\n");
+ if(advTokIdx(&i, sizeof(pcpat_wildVar) -1))
+ return;
+ } else if(pcComparePattern(&tokArr[i], pcpat_Var, tokIdx +10 -i)) {
+ fprintf(stderr,"has a var\n");
+ if(advTokIdx(&i, sizeof(pcpat_Var) -1))
+ return;
+ } else if(tokArr[i].tt == PCT_NUMBER) {
+ fprintf(stderr,"has a number\n");
+ if (advTokIdx(&i, 1))
+ return;
+ } else
+ return;
+#endif
+
+}
+
+void peepRules2pCode(peepRule *rules)
+{
+ peepRule *pr;
+ lineNode *ln;
+
+ for (pr = rules; pr; pr = pr->next) {
+ fprintf(stderr,"\nRule:\n\n");
+ for(ln = pr->match; ln; ln = ln->next) {
+ fprintf(stderr,"%s\n",ln->line);
+ //parseLineNode(ln->line);
+ parseLineNode(ln->line);
+ dumpTokens();
+
+ }
+
+ fprintf(stderr,"\nReplaced by:\n");
+ for(ln = pr->replace; ln; ln = ln->next)
+ fprintf(stderr,"%s\n",ln->line);
+
+ if(pr->cond)
+ fprintf(stderr,"\nCondition: %s\n",pr->cond);
+
+ }
+
+}
void printpCodeString(FILE *of, pCode *pc, int max)
{
peepSnippets = DLL_append((_DLL*)peepSnippets,(_DLL*)pcps);
{
+ /*
+ target:
+
+ btfsc %0
+ goto %1
+ %3
+ %1: %4
+
+ replace:
+ btfss %0
+ %1: %4
+ %3
+
+ The %3 and %4 are wild opcodes. Since the opcodes
+ are stored in a different array than the wild operands,
+ they can have the same indices and not conflict. So
+ below, the %3 is really a %0, %4 is a %1.
+
+ */
pCodeOp *pcl;
pCodeOp *pcw;
pCodeOp *pcwb;
+ // Create a new wild operand subtyped as a bit
pcwb = newpCodeOpWild(0,pcp,newpCodeOpBit(NULL,-1));
+
+ // Create a
pb = newpCodeChain(NULL, 'W',newpCode(POC_BTFSC,pcwb));
pcl = newpCodeOpLabel(-1);
if(pcr->type == PC_OPCODE) {
if(PCI(pcr)->pcop)
pcop = pCodeOpCopy(PCI(pcr)->pcop);
-
+ fprintf(stderr,"inserting pCode\n");
pCodeInsertAfter(pc, newpCode(PCI(pcr)->op,pcop));
} else if (pcr->type == PC_WILD) {
pCodeInsertAfter(pc,peepBlock->wildpCodes[PCW(pcr)->id]);
return 0;
}
+
+
+
+
+
+
+
+
+
+
+#if 0
+/*******************/
+pCode *parseLineNode(char *ln)
+{
+ char buffer[50], *s;
+ int state=0; //0 label, 1 mnemonic, 2 operand, 3 operand, 4 comment
+ int var;
+ pCode *pc = NULL;
+ // pCodeLabel *pcl = NULL;
+
+ if(!ln || !*ln)
+ return pc;
+
+ s = buffer;
+ *s = 0;
+
+ while(*ln) {
+
+ /* skip white space */
+ while (isspace (*ln))
+ ln++;
+
+ switch(state) {
+
+ case 0: // look for a label
+ case 1: // look for mnemonic
+
+ if(*ln == '%') {
+
+ // Wild
+
+ ln++;
+ if(!isdigit(*ln) )
+ break;
+ //goto next_state;
+
+ var = strtol(ln, &ln, 10);
+ if(*ln == ':') {
+ // valid wild card label
+ fprintf(stderr, " wildcard label: %d\n",var);
+ ln++;
+ } else
+ fprintf(stderr, " wild opcode: %d\n",var), state++;
+
+ } else {
+ // not wild
+ // Extract the label/mnemonic from the line
+
+ s = buffer;
+ while(*ln && !(isspace(*ln) || *ln == ':'))
+ *s++ = *ln++;
+
+ *s = 0;
+ if(*ln == ':')
+ fprintf(stderr," regular label: %s\n",buffer), ln++;
+ else
+ fprintf(stderr," regular mnem: %s\n",buffer), state++;
+ }
+ state++;
+ break;
+
+ default:
+ ln++;
+
+ }
+ }
+
+ return pc;
+
+}
+#endif