diff options
Diffstat (limited to 'ldmicro/intcode.cpp')
| -rw-r--r-- | ldmicro/intcode.cpp | 1179 |
1 files changed, 1179 insertions, 0 deletions
diff --git a/ldmicro/intcode.cpp b/ldmicro/intcode.cpp new file mode 100644 index 0000000..a577759 --- /dev/null +++ b/ldmicro/intcode.cpp @@ -0,0 +1,1179 @@ +//----------------------------------------------------------------------------- +// Copyright 2007 Jonathan Westhues +// +// This file is part of LDmicro. +// +// LDmicro is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// LDmicro is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with LDmicro. If not, see <http://www.gnu.org/licenses/>. +//------ +// +// Generate intermediate code for the ladder logic. Basically generate code +// for a `virtual machine' with operations chosen to be easy to compile to +// AVR or PIC16 code. +// Jonathan Westhues, Nov 2004 +//----------------------------------------------------------------------------- +#include "linuxUI.h" +#include <stdio.h> +#include <setjmp.h> +#include <stdlib.h> + +#include "ldmicro.h" +#include "intcode.h" + +IntOp IntCode[MAX_INT_OPS]; +int IntCodeLen; + +static DWORD GenSymCountParThis; +static DWORD GenSymCountParOut; +static DWORD GenSymCountOneShot; +static DWORD GenSymCountFormattedString; + +static WORD EepromAddrFree; + +//----------------------------------------------------------------------------- +// Pretty-print the intermediate code to a file, for debugging purposes. +//----------------------------------------------------------------------------- +void IntDumpListing(char *outFile) +{ + FILE *f = fopen(outFile, "w"); + if(!f) { + Error("Couldn't dump intermediate code to '%s'.", outFile); + } + + int i; + int indent = 0; + for(i = 0; i < IntCodeLen; i++) { + + if(IntCode[i].op == INT_END_IF) indent--; + if(IntCode[i].op == INT_ELSE) indent--; + + fprintf(f, "%3d:", i); + int j; + for(j = 0; j < indent; j++) fprintf(f, " "); + + switch(IntCode[i].op) { + case INT_SET_BIT: + fprintf(f, "set bit '%s'", IntCode[i].name1); + break; + + case INT_CLEAR_BIT: + fprintf(f, "clear bit '%s'", IntCode[i].name1); + break; + + case INT_COPY_BIT_TO_BIT: + fprintf(f, "let bit '%s' := '%s'", IntCode[i].name1, + IntCode[i].name2); + break; + + case INT_SET_VARIABLE_TO_LITERAL: + fprintf(f, "let var '%s' := %d", IntCode[i].name1, + IntCode[i].literal); + break; + + case INT_SET_VARIABLE_TO_VARIABLE: + fprintf(f, "let var '%s' := '%s'", IntCode[i].name1, + IntCode[i].name2); + break; + + case INT_SET_VARIABLE_ADD: + fprintf(f, "let var '%s' := '%s' + '%s'", IntCode[i].name1, + IntCode[i].name2, IntCode[i].name3); + break; + + case INT_SET_VARIABLE_SUBTRACT: + fprintf(f, "let var '%s' := '%s' - '%s'", IntCode[i].name1, + IntCode[i].name2, IntCode[i].name3); + break; + + case INT_SET_VARIABLE_MULTIPLY: + fprintf(f, "let var '%s' := '%s' * '%s'", IntCode[i].name1, + IntCode[i].name2, IntCode[i].name3); + break; + + case INT_SET_VARIABLE_DIVIDE: + fprintf(f, "let var '%s' := '%s' / '%s'", IntCode[i].name1, + IntCode[i].name2, IntCode[i].name3); + break; + + case INT_INCREMENT_VARIABLE: + fprintf(f, "increment '%s'", IntCode[i].name1); + break; + + case INT_READ_ADC: + fprintf(f, "read adc '%s'", IntCode[i].name1); + break; + + case INT_SET_PWM: + fprintf(f, "set pwm '%s' %s Hz", IntCode[i].name1, + IntCode[i].name2); + break; + + case INT_EEPROM_BUSY_CHECK: + fprintf(f, "set bit '%s' if EEPROM busy", IntCode[i].name1); + break; + + case INT_EEPROM_READ: + fprintf(f, "read EEPROM[%d,%d+1] into '%s'", + IntCode[i].literal, IntCode[i].literal, IntCode[i].name1); + break; + + case INT_EEPROM_WRITE: + fprintf(f, "write '%s' into EEPROM[%d,%d+1]", + IntCode[i].name1, IntCode[i].literal, IntCode[i].literal); + break; + + case INT_UART_SEND: + fprintf(f, "uart send from '%s', done? into '%s'", + IntCode[i].name1, IntCode[i].name2); + break; + + case INT_UART_RECV: + fprintf(f, "uart recv int '%s', have? into '%s'", + IntCode[i].name1, IntCode[i].name2); + break; + + case INT_IF_BIT_SET: + fprintf(f, "if '%s' {", IntCode[i].name1); indent++; + break; + + case INT_IF_BIT_CLEAR: + fprintf(f, "if not '%s' {", IntCode[i].name1); indent++; + break; + + case INT_IF_VARIABLE_LES_LITERAL: + fprintf(f, "if '%s' < %d {", IntCode[i].name1, + IntCode[i].literal); indent++; + break; + + case INT_IF_VARIABLE_EQUALS_VARIABLE: + fprintf(f, "if '%s' == '%s' {", IntCode[i].name1, + IntCode[i].name2); indent++; + break; + + case INT_IF_VARIABLE_GRT_VARIABLE: + fprintf(f, "if '%s' > '%s' {", IntCode[i].name1, + IntCode[i].name2); indent++; + break; + + case INT_END_IF: + fprintf(f, "}"); + break; + + case INT_ELSE: + fprintf(f, "} else {"); indent++; + break; + + case INT_SIMULATE_NODE_STATE: + // simulation-only; the real code generators don't care + break; + + case INT_COMMENT: + fprintf(f, "# %s", IntCode[i].name1); + break; + + default: + oops(); + } + fprintf(f, "\n"); + fflush(f); + } + fclose(f); +} + +//----------------------------------------------------------------------------- +// Convert a hex digit (0-9a-fA-F) to its hex value, or return -1 if the +// character is not a hex digit. +//----------------------------------------------------------------------------- +int HexDigit(int c) +{ + if((c >= '0') && (c <= '9')) { + return c - '0'; + } else if((c >= 'a') && (c <= 'f')) { + return 10 + (c - 'a'); + } else if((c >= 'A') && (c <= 'F')) { + return 10 + (c - 'A'); + } + return -1; +} + +//----------------------------------------------------------------------------- +// Generate a unique symbol (unique with each call) having the given prefix +// guaranteed not to conflict with any user symbols. +//----------------------------------------------------------------------------- +static void GenSymParThis(char *dest) +{ + sprintf(dest, "$parThis_%04x", GenSymCountParThis); + GenSymCountParThis++; +} +static void GenSymParOut(char *dest) +{ + sprintf(dest, "$parOut_%04x", GenSymCountParOut); + GenSymCountParOut++; +} +static void GenSymOneShot(char *dest) +{ + sprintf(dest, "$oneShot_%04x", GenSymCountOneShot); + GenSymCountOneShot++; +} +static void GenSymFormattedString(char *dest) +{ + sprintf(dest, "$formattedString_%04x", GenSymCountFormattedString); + GenSymCountFormattedString++; +} + +//----------------------------------------------------------------------------- +// Compile an instruction to the program. +//----------------------------------------------------------------------------- +static void Op(int op, char *name1, char *name2, char *name3, SWORD lit) +{ + IntCode[IntCodeLen].op = op; + if(name1) strcpy(IntCode[IntCodeLen].name1, name1); + if(name2) strcpy(IntCode[IntCodeLen].name2, name2); + if(name3) strcpy(IntCode[IntCodeLen].name3, name3); + IntCode[IntCodeLen].literal = lit; + IntCodeLen++; +} +static void Op(int op, char *name1, char *name2, SWORD lit) +{ + Op(op, name1, name2, NULL, lit); +} +static void Op(int op, char *name1, SWORD lit) +{ + Op(op, name1, NULL, NULL, lit); +} +static void Op(int op, char *name1, char *name2) +{ + Op(op, name1, name2, NULL, 0); +} +static void Op(int op, char *name1) +{ + Op(op, name1, NULL, NULL, 0); +} +static void Op(int op) +{ + Op(op, NULL, NULL, NULL, 0); +} + +//----------------------------------------------------------------------------- +// Compile the instruction that the simulator uses to keep track of which +// nodes are energized (so that it can display which branches of the circuit +// are energized onscreen). The MCU code generators ignore this, of course. +//----------------------------------------------------------------------------- +static void SimState(BOOL *b, char *name) +{ + IntCode[IntCodeLen].op = INT_SIMULATE_NODE_STATE; + strcpy(IntCode[IntCodeLen].name1, name); + IntCode[IntCodeLen].poweredAfter = b; + IntCodeLen++; +} + +//----------------------------------------------------------------------------- +// printf-like comment function +//----------------------------------------------------------------------------- +void Comment(char *str, ...) +{ + va_list f; + char buf[MAX_NAME_LEN]; + va_start(f, str); + vsprintf(buf, str, f); + Op(INT_COMMENT, buf); +} + +//----------------------------------------------------------------------------- +// Calculate the period in scan units from the period in microseconds, and +// raise an error if the given period is unachievable. +//----------------------------------------------------------------------------- +static int TimerPeriod(ElemLeaf *l) +{ + int period = (l->d.timer.delay / Prog.cycleTime) - 1; + + if(period < 1) { + Error(_("Timer period too short (needs faster cycle time).")); + CompileError(); + } + if(period >= (1 << 15)) { + Error(_("Timer period too long (max 32767 times cycle time); use a " + "slower cycle time.")); + CompileError(); + } + + return period; +} + +//----------------------------------------------------------------------------- +// Is an expression that could be either a variable name or a number a number? +//----------------------------------------------------------------------------- +static BOOL IsNumber(char *str) +{ + if(*str == '-' || isdigit(*str)) { + return TRUE; + } else if(*str == '\'') { + // special case--literal single character + return TRUE; + } else { + return FALSE; + } +} + +//----------------------------------------------------------------------------- +// Report an error if a constant doesn't fit in 16 bits. +//----------------------------------------------------------------------------- +void CheckConstantInRange(int v) +{ + if(v < -32768 || v > 32767) { + Error(_("Constant %d out of range: -32768 to 32767 inclusive."), v); + CompileError(); + } +} + +//----------------------------------------------------------------------------- +// Try to turn a string into a 16-bit constant, and raise an error if +// something bad happens when we do so (e.g. out of range). +//----------------------------------------------------------------------------- +SWORD CheckMakeNumber(char *str) +{ + int val; + + if(*str == '\'') { + val = str[1]; + } else { + val = atoi(str); + } + + CheckConstantInRange(val); + + return (SWORD)val; +} + +//----------------------------------------------------------------------------- +// Return an integer power of ten. +//----------------------------------------------------------------------------- +static int TenToThe(int x) +{ + int i; + int r = 1; + for(i = 0; i < x; i++) { + r *= 10; + } + return r; +} + +//----------------------------------------------------------------------------- +// Compile code to evaluate the given bit of ladder logic. The rung input +// state is in stateInOut before calling and will be in stateInOut after +// calling. +//----------------------------------------------------------------------------- +static char *VarFromExpr(char *expr, char *tempName) +{ + if(IsNumber(expr)) { + Op(INT_SET_VARIABLE_TO_LITERAL, tempName, CheckMakeNumber(expr)); + return tempName; + } else { + return expr; + } +} +static void IntCodeFromCircuit(int which, void *any, char *stateInOut) +{ + ElemLeaf *l = (ElemLeaf *)any; + + switch(which) { + case ELEM_SERIES_SUBCKT: { + int i; + ElemSubcktSeries *s = (ElemSubcktSeries *)any; + + Comment("start series ["); + for(i = 0; i < s->count; i++) { + IntCodeFromCircuit(s->contents[i].which, s->contents[i].d.any, + stateInOut); + } + Comment("] finish series"); + break; + } + case ELEM_PARALLEL_SUBCKT: { + char parThis[MAX_NAME_LEN]; + GenSymParThis(parThis); + + char parOut[MAX_NAME_LEN]; + GenSymParOut(parOut); + + Comment("start parallel ["); + + Op(INT_CLEAR_BIT, parOut); + + ElemSubcktParallel *p = (ElemSubcktParallel *)any; + int i; + for(i = 0; i < p->count; i++) { + Op(INT_COPY_BIT_TO_BIT, parThis, stateInOut); + + IntCodeFromCircuit(p->contents[i].which, p->contents[i].d.any, + parThis); + + Op(INT_IF_BIT_SET, parThis); + Op(INT_SET_BIT, parOut); + Op(INT_END_IF); + } + Op(INT_COPY_BIT_TO_BIT, stateInOut, parOut); + Comment("] finish parallel"); + + break; + } + case ELEM_CONTACTS: { + if(l->d.contacts.negated) { + Op(INT_IF_BIT_SET, l->d.contacts.name); + } else { + Op(INT_IF_BIT_CLEAR, l->d.contacts.name); + } + Op(INT_CLEAR_BIT, stateInOut); + Op(INT_END_IF); + break; + } + case ELEM_COIL: { + if(l->d.coil.negated) { + Op(INT_IF_BIT_SET, stateInOut); + Op(INT_CLEAR_BIT, l->d.contacts.name); + Op(INT_ELSE); + Op(INT_SET_BIT, l->d.contacts.name); + Op(INT_END_IF); + } else if(l->d.coil.setOnly) { + Op(INT_IF_BIT_SET, stateInOut); + Op(INT_SET_BIT, l->d.contacts.name); + Op(INT_END_IF); + } else if(l->d.coil.resetOnly) { + Op(INT_IF_BIT_SET, stateInOut); + Op(INT_CLEAR_BIT, l->d.contacts.name); + Op(INT_END_IF); + } else { + Op(INT_COPY_BIT_TO_BIT, l->d.contacts.name, stateInOut); + } + break; + } + case ELEM_RTO: { + int period = TimerPeriod(l); + + Op(INT_IF_VARIABLE_LES_LITERAL, l->d.timer.name, period); + + Op(INT_IF_BIT_SET, stateInOut); + Op(INT_INCREMENT_VARIABLE, l->d.timer.name); + Op(INT_END_IF); + Op(INT_CLEAR_BIT, stateInOut); + + Op(INT_ELSE); + + Op(INT_SET_BIT, stateInOut); + + Op(INT_END_IF); + + break; + } + case ELEM_RES: + Op(INT_IF_BIT_SET, stateInOut); + Op(INT_SET_VARIABLE_TO_LITERAL, l->d.reset.name); + Op(INT_END_IF); + break; + + case ELEM_TON: { + int period = TimerPeriod(l); + + Op(INT_IF_BIT_SET, stateInOut); + + Op(INT_IF_VARIABLE_LES_LITERAL, l->d.timer.name, period); + + Op(INT_INCREMENT_VARIABLE, l->d.timer.name); + Op(INT_CLEAR_BIT, stateInOut); + Op(INT_END_IF); + + Op(INT_ELSE); + + Op(INT_SET_VARIABLE_TO_LITERAL, l->d.timer.name); + + Op(INT_END_IF); + + break; + } + case ELEM_TOF: { + int period = TimerPeriod(l); + + // All variables start at zero by default, so by default the + // TOF timer would start out with its output forced HIGH, until + // it finishes counting up. This does not seem to be what + // people expect, so add a special case to fix that up. + char antiGlitchName[MAX_NAME_LEN]; + sprintf(antiGlitchName, "$%s_antiglitch", l->d.timer.name); + Op(INT_IF_BIT_CLEAR, antiGlitchName); + Op(INT_SET_VARIABLE_TO_LITERAL, l->d.timer.name, period); + Op(INT_END_IF); + Op(INT_SET_BIT, antiGlitchName); + + Op(INT_IF_BIT_CLEAR, stateInOut); + + Op(INT_IF_VARIABLE_LES_LITERAL, l->d.timer.name, period); + + Op(INT_INCREMENT_VARIABLE, l->d.timer.name); + Op(INT_SET_BIT, stateInOut); + Op(INT_END_IF); + + Op(INT_ELSE); + + Op(INT_SET_VARIABLE_TO_LITERAL, l->d.timer.name); + + Op(INT_END_IF); + break; + } + case ELEM_CTU: { + CheckConstantInRange(l->d.counter.max); + char storeName[MAX_NAME_LEN]; + GenSymOneShot(storeName); + + Op(INT_IF_BIT_SET, stateInOut); + Op(INT_IF_BIT_CLEAR, storeName); + Op(INT_INCREMENT_VARIABLE, l->d.counter.name); + Op(INT_END_IF); + Op(INT_END_IF); + Op(INT_COPY_BIT_TO_BIT, storeName, stateInOut); + + Op(INT_IF_VARIABLE_LES_LITERAL, l->d.counter.name, + l->d.counter.max); + Op(INT_CLEAR_BIT, stateInOut); + Op(INT_ELSE); + Op(INT_SET_BIT, stateInOut); + Op(INT_END_IF); + break; + } + case ELEM_CTD: { + CheckConstantInRange(l->d.counter.max); + char storeName[MAX_NAME_LEN]; + GenSymOneShot(storeName); + + Op(INT_IF_BIT_SET, stateInOut); + Op(INT_IF_BIT_CLEAR, storeName); + Op(INT_SET_VARIABLE_TO_LITERAL, "$scratch", 1); + Op(INT_SET_VARIABLE_SUBTRACT, l->d.counter.name, + l->d.counter.name, "$scratch", 0); + Op(INT_END_IF); + Op(INT_END_IF); + Op(INT_COPY_BIT_TO_BIT, storeName, stateInOut); + + Op(INT_IF_VARIABLE_LES_LITERAL, l->d.counter.name, + l->d.counter.max); + Op(INT_CLEAR_BIT, stateInOut); + Op(INT_ELSE); + Op(INT_SET_BIT, stateInOut); + Op(INT_END_IF); + break; + } + case ELEM_CTC: { + char storeName[MAX_NAME_LEN]; + GenSymOneShot(storeName); + + Op(INT_IF_BIT_SET, stateInOut); + Op(INT_IF_BIT_CLEAR, storeName); + Op(INT_INCREMENT_VARIABLE, l->d.counter.name); + Op(INT_IF_VARIABLE_LES_LITERAL, l->d.counter.name, + l->d.counter.max+1); + Op(INT_ELSE); + Op(INT_SET_VARIABLE_TO_LITERAL, l->d.counter.name, + (SWORD)0); + Op(INT_END_IF); + Op(INT_END_IF); + Op(INT_END_IF); + Op(INT_COPY_BIT_TO_BIT, storeName, stateInOut); + break; + } + case ELEM_GRT: + case ELEM_GEQ: + case ELEM_LES: + case ELEM_LEQ: + case ELEM_NEQ: + case ELEM_EQU: { + char *op1 = VarFromExpr(l->d.cmp.op1, "$scratch"); + char *op2 = VarFromExpr(l->d.cmp.op2, "$scratch2"); + + if(which == ELEM_GRT) { + Op(INT_IF_VARIABLE_GRT_VARIABLE, op1, op2); + Op(INT_ELSE); + } else if(which == ELEM_GEQ) { + Op(INT_IF_VARIABLE_GRT_VARIABLE, op2, op1); + } else if(which == ELEM_LES) { + Op(INT_IF_VARIABLE_GRT_VARIABLE, op2, op1); + Op(INT_ELSE); + } else if(which == ELEM_LEQ) { + Op(INT_IF_VARIABLE_GRT_VARIABLE, op1, op2); + } else if(which == ELEM_EQU) { + Op(INT_IF_VARIABLE_EQUALS_VARIABLE, op1, op2); + Op(INT_ELSE); + } else if(which == ELEM_NEQ) { + Op(INT_IF_VARIABLE_EQUALS_VARIABLE, op1, op2); + } else oops(); + + Op(INT_CLEAR_BIT, stateInOut); + Op(INT_END_IF); + break; + } + case ELEM_ONE_SHOT_RISING: { + char storeName[MAX_NAME_LEN]; + GenSymOneShot(storeName); + + Op(INT_COPY_BIT_TO_BIT, "$scratch", stateInOut); + Op(INT_IF_BIT_SET, storeName); + Op(INT_CLEAR_BIT, stateInOut); + Op(INT_END_IF); + Op(INT_COPY_BIT_TO_BIT, storeName, "$scratch"); + break; + } + case ELEM_ONE_SHOT_FALLING: { + char storeName[MAX_NAME_LEN]; + GenSymOneShot(storeName); + + Op(INT_COPY_BIT_TO_BIT, "$scratch", stateInOut); + + Op(INT_IF_BIT_CLEAR, stateInOut); + Op(INT_IF_BIT_SET, storeName); + Op(INT_SET_BIT, stateInOut); + Op(INT_END_IF); + Op(INT_ELSE); + Op(INT_CLEAR_BIT, stateInOut); + Op(INT_END_IF); + + Op(INT_COPY_BIT_TO_BIT, storeName, "$scratch"); + break; + } + case ELEM_MOVE: { + if(IsNumber(l->d.move.dest)) { + Error(_("Move instruction: '%s' not a valid destination."), + l->d.move.dest); + CompileError(); + } + Op(INT_IF_BIT_SET, stateInOut); + if(IsNumber(l->d.move.src)) { + Op(INT_SET_VARIABLE_TO_LITERAL, l->d.move.dest, + CheckMakeNumber(l->d.move.src)); + } else { + Op(INT_SET_VARIABLE_TO_VARIABLE, l->d.move.dest, l->d.move.src, + 0); + } + Op(INT_END_IF); + break; + } + + // These four are highly processor-dependent; the int code op does + // most of the highly specific work + { + case ELEM_READ_ADC: + Op(INT_IF_BIT_SET, stateInOut); + Op(INT_READ_ADC, l->d.readAdc.name); + Op(INT_END_IF); + break; + + case ELEM_SET_PWM: { + Op(INT_IF_BIT_SET, stateInOut); + char line[80]; + // ugh; need a >16 bit literal though, could be >64 kHz + sprintf(line, "%d", l->d.setPwm.targetFreq); + Op(INT_SET_PWM, l->d.readAdc.name, line); + Op(INT_END_IF); + break; + } + case ELEM_PERSIST: { + Op(INT_IF_BIT_SET, stateInOut); + + // At startup, get the persistent variable from flash. + char isInit[MAX_NAME_LEN]; + GenSymOneShot(isInit); + Op(INT_IF_BIT_CLEAR, isInit); + Op(INT_CLEAR_BIT, "$scratch"); + Op(INT_EEPROM_BUSY_CHECK, "$scratch"); + Op(INT_IF_BIT_CLEAR, "$scratch"); + Op(INT_SET_BIT, isInit); + Op(INT_EEPROM_READ, l->d.persist.var, EepromAddrFree); + Op(INT_END_IF); + Op(INT_END_IF); + + // While running, continuously compare the EEPROM copy of + // the variable against the RAM one; if they are different, + // write the RAM one to EEPROM. + Op(INT_CLEAR_BIT, "$scratch"); + Op(INT_EEPROM_BUSY_CHECK, "$scratch"); + Op(INT_IF_BIT_CLEAR, "$scratch"); + Op(INT_EEPROM_READ, "$scratch", EepromAddrFree); + Op(INT_IF_VARIABLE_EQUALS_VARIABLE, "$scratch", + l->d.persist.var); + Op(INT_ELSE); + Op(INT_EEPROM_WRITE, l->d.persist.var, EepromAddrFree); + Op(INT_END_IF); + Op(INT_END_IF); + + Op(INT_END_IF); + + EepromAddrFree += 2; + break; + } + case ELEM_UART_SEND: + Op(INT_UART_SEND, l->d.uart.name, stateInOut); + break; + + case ELEM_UART_RECV: + Op(INT_IF_BIT_SET, stateInOut); + Op(INT_UART_RECV, l->d.uart.name, stateInOut); + Op(INT_END_IF); + break; + } + + case ELEM_ADD: + case ELEM_SUB: + case ELEM_MUL: + case ELEM_DIV: { + if(IsNumber(l->d.math.dest)) { + Error(_("Math instruction: '%s' not a valid destination."), + l->d.math.dest); + CompileError(); + } + Op(INT_IF_BIT_SET, stateInOut); + + char *op1 = VarFromExpr(l->d.math.op1, "$scratch"); + char *op2 = VarFromExpr(l->d.math.op2, "$scratch2"); + + int intOp; + if(which == ELEM_ADD) { + intOp = INT_SET_VARIABLE_ADD; + } else if(which == ELEM_SUB) { + intOp = INT_SET_VARIABLE_SUBTRACT; + } else if(which == ELEM_MUL) { + intOp = INT_SET_VARIABLE_MULTIPLY; + } else if(which == ELEM_DIV) { + intOp = INT_SET_VARIABLE_DIVIDE; + } else oops(); + + Op(intOp, l->d.math.dest, op1, op2, 0); + + Op(INT_END_IF); + break; + } + case ELEM_MASTER_RELAY: + // Tricky: must set the master control relay if we reach this + // instruction while the master control relay is cleared, because + // otherwise there is no good way for it to ever become set + // again. + Op(INT_IF_BIT_CLEAR, "$mcr"); + Op(INT_SET_BIT, "$mcr"); + Op(INT_ELSE); + Op(INT_COPY_BIT_TO_BIT, "$mcr", stateInOut); + Op(INT_END_IF); + break; + + case ELEM_SHIFT_REGISTER: { + char storeName[MAX_NAME_LEN]; + GenSymOneShot(storeName); + Op(INT_IF_BIT_SET, stateInOut); + Op(INT_IF_BIT_CLEAR, storeName); + int i; + for(i = (l->d.shiftRegister.stages-2); i >= 0; i--) { + char dest[MAX_NAME_LEN+10], src[MAX_NAME_LEN+10]; + sprintf(src, "%s%d", l->d.shiftRegister.name, i); + sprintf(dest, "%s%d", l->d.shiftRegister.name, i+1); + Op(INT_SET_VARIABLE_TO_VARIABLE, dest, src); + } + Op(INT_END_IF); + Op(INT_END_IF); + Op(INT_COPY_BIT_TO_BIT, storeName, stateInOut); + break; + } + case ELEM_LOOK_UP_TABLE: { + // God this is stupid; but it will have to do, at least until I + // add new int code instructions for this. + int i; + Op(INT_IF_BIT_SET, stateInOut); + ElemLookUpTable *t = &(l->d.lookUpTable); + for(i = 0; i < t->count; i++) { + Op(INT_SET_VARIABLE_TO_LITERAL, "$scratch", i); + Op(INT_IF_VARIABLE_EQUALS_VARIABLE, t->index, "$scratch"); + Op(INT_SET_VARIABLE_TO_LITERAL, t->dest, t->vals[i]); + Op(INT_END_IF); + } + Op(INT_END_IF); + break; + } + case ELEM_PIECEWISE_LINEAR: { + // This one is not so obvious; we have to decide how best to + // perform the linear interpolation, using our 16-bit fixed + // point math. + ElemPiecewiseLinear *t = &(l->d.piecewiseLinear); + if(t->count == 0) { + Error(_("Piecewise linear lookup table with zero elements!")); + CompileError(); + } + int i; + int xThis = t->vals[0]; + for(i = 1; i < t->count; i++) { + if(t->vals[i*2] <= xThis) { + Error(_("x values in piecewise linear table must be " + "strictly increasing.")); + CompileError(); + } + xThis = t->vals[i*2]; + } + Op(INT_IF_BIT_SET, stateInOut); + for(i = t->count - 1; i >= 1; i--) { + int thisDx = t->vals[i*2] - t->vals[(i-1)*2]; + int thisDy = t->vals[i*2 + 1] - t->vals[(i-1)*2 + 1]; + // The output point is given by + // yout = y[i-1] + (xin - x[i-1])*dy/dx + // and this is the best form in which to keep it, numerically + // speaking, because you can always fix numerical problems + // by moving the PWL points closer together. + + // Check for numerical problems, and fail if we have them. + if((thisDx*thisDy) >= 32767 || (thisDx*thisDy) <= -32768) { + Error(_("Numerical problem with piecewise linear lookup " + "table. Either make the table entries smaller, " + "or space the points together more closely.\r\n\r\n" + "See the help file for details.")); + CompileError(); + } + + // Hack to avoid AVR brge issue again, since long jumps break + Op(INT_CLEAR_BIT, "$scratch"); + Op(INT_IF_VARIABLE_LES_LITERAL, t->index, t->vals[i*2]+1); + Op(INT_SET_BIT, "$scratch"); + Op(INT_END_IF); + + Op(INT_IF_BIT_SET, "$scratch"); + Op(INT_SET_VARIABLE_TO_LITERAL, "$scratch", t->vals[(i-1)*2]); + Op(INT_SET_VARIABLE_SUBTRACT, "$scratch", t->index, + "$scratch", 0); + Op(INT_SET_VARIABLE_TO_LITERAL, "$scratch2", thisDx); + Op(INT_SET_VARIABLE_TO_LITERAL, "$scratch3", thisDy); + Op(INT_SET_VARIABLE_MULTIPLY, t->dest, "$scratch", "$scratch3", + 0); + Op(INT_SET_VARIABLE_DIVIDE, t->dest, t->dest, "$scratch2", 0); + + Op(INT_SET_VARIABLE_TO_LITERAL, "$scratch", + t->vals[(i-1)*2 + 1]); + Op(INT_SET_VARIABLE_ADD, t->dest, t->dest, "$scratch", 0); + Op(INT_END_IF); + } + Op(INT_END_IF); + break; + } + case ELEM_FORMATTED_STRING: { + // Okay, this one is terrible and ineffcient, and it's a huge pain + // to implement, but people want it a lot. The hard part is that + // we have to let the PLC keep cycling, of course, and also that + // we must do the integer to ASCII conversion sensisbly, with + // only one divide per PLC cycle. + + // This variable is basically our sequencer: it is a counter that + // increments every time we send a character. + char seq[MAX_NAME_LEN]; + GenSymFormattedString(seq); + + // The variable whose value we might interpolate. + char *var = l->d.fmtdStr.var; + + // This is the state variable for our integer-to-string conversion. + // It contains the absolute value of var, possibly with some + // of the higher powers of ten missing. + char convertState[MAX_NAME_LEN]; + GenSymFormattedString(convertState); + + // We might need to suppress some leading zeros. + char isLeadingZero[MAX_NAME_LEN]; + GenSymFormattedString(isLeadingZero); + + // This is a table of characters to transmit, as a function of the + // sequencer position (though we might have a hole in the middle + // for the variable output) + char outputChars[MAX_LOOK_UP_TABLE_LEN]; + + BOOL mustDoMinus = FALSE; + + // The total number of characters that we transmit, including + // those from the interpolated variable. + int steps; + + // The total number of digits to convert. + int digits = -1; + + // So count that now, and build up our table of fixed things to + // send. + steps = 0; + char *p = l->d.fmtdStr.string; + while(*p) { + if(*p == '\\' && (isdigit(p[1]) || p[1] == '-')) { + if(digits >= 0) { + Error(_("Multiple escapes (\\0-9) present in format " + "string, not allowed.")); + CompileError(); + } + p++; + if(*p == '-') { + mustDoMinus = TRUE; + outputChars[steps++] = 1; + p++; + } + if(!isdigit(*p) || (*p - '0') > 5 || *p == '0') { + Error(_("Bad escape sequence following \\; for a " + "literal backslash, use \\\\")); + CompileError(); + } + digits = (*p - '0'); + int i; + for(i = 0; i < digits; i++) { + outputChars[steps++] = 0; + } + } else if(*p == '\\') { + p++; + switch(*p) { + case 'r': outputChars[steps++] = '\r'; break; + case 'n': outputChars[steps++] = '\n'; break; + case 'b': outputChars[steps++] = '\b'; break; + case 'f': outputChars[steps++] = '\f'; break; + case '\\': outputChars[steps++] = '\\'; break; + case 'x': { + int h, l; + p++; + h = HexDigit(*p); + if(h >= 0) { + p++; + l = HexDigit(*p); + if(l >= 0) { + outputChars[steps++] = (h << 4) | l; + break; + } + } + Error(_("Bad escape: correct form is \\xAB.")); + CompileError(); + break; + } + default: + Error(_("Bad escape '\\%c'"), *p); + CompileError(); + break; + } + } else { + outputChars[steps++] = *p; + } + if(*p) p++; + } + + if(digits >= 0 && (strlen(var) == 0)) { + Error(_("Variable is interpolated into formatted string, but " + "none is specified.")); + CompileError(); + } else if(digits < 0 && (strlen(var) > 0)) { + Error(_("No variable is interpolated into formatted string, " + "but a variable name is specified. Include a string like " + "'\\-3', or leave variable name blank.")); + CompileError(); + } + + // We want to respond to rising edges, so yes we need a one shot. + char oneShot[MAX_NAME_LEN]; + GenSymOneShot(oneShot); + + Op(INT_IF_BIT_SET, stateInOut); + Op(INT_IF_BIT_CLEAR, oneShot); + Op(INT_SET_VARIABLE_TO_LITERAL, seq, (SWORD)0); + Op(INT_END_IF); + Op(INT_END_IF); + Op(INT_COPY_BIT_TO_BIT, oneShot, stateInOut); + + // Everything that involves seqScratch is a terrible hack to + // avoid an if statement with a big body, which is the risk + // factor for blowing up on PIC16 page boundaries. + + char *seqScratch = "$scratch3"; + + Op(INT_SET_VARIABLE_TO_VARIABLE, seqScratch, seq); + + // No point doing any math unless we'll get to transmit this + // cycle, so check that first. + + Op(INT_IF_VARIABLE_LES_LITERAL, seq, steps); + Op(INT_ELSE); + Op(INT_SET_VARIABLE_TO_LITERAL, seqScratch, -1); + Op(INT_END_IF); + + Op(INT_CLEAR_BIT, "$scratch"); + Op(INT_UART_SEND, "$scratch", "$scratch"); + Op(INT_IF_BIT_SET, "$scratch"); + Op(INT_SET_VARIABLE_TO_LITERAL, seqScratch, -1); + Op(INT_END_IF); + + // So we transmit this cycle, so check out which character. + int i; + int digit = 0; + for(i = 0; i < steps; i++) { + if(outputChars[i] == 0) { + // Note gross hack to work around limit of range for + // AVR brne op, which is +/- 64 instructions. + Op(INT_SET_VARIABLE_TO_LITERAL, "$scratch", i); + Op(INT_CLEAR_BIT, "$scratch"); + Op(INT_IF_VARIABLE_EQUALS_VARIABLE, "$scratch", seqScratch); + Op(INT_SET_BIT, "$scratch"); + Op(INT_END_IF); + + Op(INT_IF_BIT_SET, "$scratch"); + + // Start the integer-to-string + + // If there's no minus, then we have to load up + // convertState ourselves the first time. + if(digit == 0 && !mustDoMinus) { + Op(INT_SET_VARIABLE_TO_VARIABLE, convertState, var); + } + if(digit == 0) { + Op(INT_SET_BIT, isLeadingZero); + } + + Op(INT_SET_VARIABLE_TO_LITERAL, "$scratch", + TenToThe((digits-digit)-1)); + Op(INT_SET_VARIABLE_DIVIDE, "$scratch2", convertState, + "$scratch", 0); + Op(INT_SET_VARIABLE_MULTIPLY, "$scratch", "$scratch", + "$scratch2", 0); + Op(INT_SET_VARIABLE_SUBTRACT, convertState, + convertState, "$scratch", 0); + Op(INT_SET_VARIABLE_TO_LITERAL, "$scratch", '0'); + Op(INT_SET_VARIABLE_ADD, "$scratch2", "$scratch2", + "$scratch", 0); + + // Suppress all but the last leading zero. + if(digit != (digits - 1)) { + Op(INT_IF_VARIABLE_EQUALS_VARIABLE, "$scratch", + "$scratch2"); + Op(INT_IF_BIT_SET, isLeadingZero); + Op(INT_SET_VARIABLE_TO_LITERAL, + "$scratch2", ' '); + Op(INT_END_IF); + Op(INT_ELSE); + Op(INT_CLEAR_BIT, isLeadingZero); + Op(INT_END_IF); + } + + Op(INT_END_IF); + + digit++; + } else if(outputChars[i] == 1) { + // do the minus; ugliness to get around the BRNE jump + // size limit, though + Op(INT_SET_VARIABLE_TO_LITERAL, "$scratch", i); + Op(INT_CLEAR_BIT, "$scratch"); + Op(INT_IF_VARIABLE_EQUALS_VARIABLE, "$scratch", seqScratch); + Op(INT_SET_BIT, "$scratch"); + Op(INT_END_IF); + Op(INT_IF_BIT_SET, "$scratch"); + + // Also do the `absolute value' calculation while + // we're at it. + Op(INT_SET_VARIABLE_TO_VARIABLE, convertState, var); + Op(INT_SET_VARIABLE_TO_LITERAL, "$scratch2", ' '); + Op(INT_IF_VARIABLE_LES_LITERAL, var, (SWORD)0); + Op(INT_SET_VARIABLE_TO_LITERAL, "$scratch2", '-'); + Op(INT_SET_VARIABLE_TO_LITERAL, "$scratch", + (SWORD)0); + Op(INT_SET_VARIABLE_SUBTRACT, convertState, + "$scratch", var, 0); + Op(INT_END_IF); + + Op(INT_END_IF); + } else { + // just another character + Op(INT_SET_VARIABLE_TO_LITERAL, "$scratch", i); + Op(INT_IF_VARIABLE_EQUALS_VARIABLE, "$scratch", seqScratch); + Op(INT_SET_VARIABLE_TO_LITERAL, "$scratch2", + outputChars[i]); + Op(INT_END_IF); + } + } + + Op(INT_IF_VARIABLE_LES_LITERAL, seqScratch, (SWORD)0); + Op(INT_ELSE); + Op(INT_SET_BIT, "$scratch"); + Op(INT_UART_SEND, "$scratch2", "$scratch"); + Op(INT_INCREMENT_VARIABLE, seq); + Op(INT_END_IF); + + // Rung-out state: true if we're still running, else false + Op(INT_CLEAR_BIT, stateInOut); + Op(INT_IF_VARIABLE_LES_LITERAL, seq, steps); + Op(INT_SET_BIT, stateInOut); + Op(INT_END_IF); + break; + } + case ELEM_OPEN: + Op(INT_CLEAR_BIT, stateInOut); + break; + + case ELEM_SHORT: + // goes straight through + break; + + case ELEM_PLACEHOLDER: + Error( + _("Empty row; delete it or add instructions before compiling.")); + CompileError(); + break; + + default: + oops(); + break; + } + + if(which != ELEM_SERIES_SUBCKT && which != ELEM_PARALLEL_SUBCKT) { + // then it is a leaf; let the simulator know which leaf it + // should be updating for display purposes + SimState(&(l->poweredAfter), stateInOut); + } +} + +//----------------------------------------------------------------------------- +// Generate intermediate code for the entire program. Return TRUE if it worked, +// else FALSE. +//----------------------------------------------------------------------------- +BOOL GenerateIntermediateCode(void) +{ + GenSymCountParThis = 0; + GenSymCountParOut = 0; + GenSymCountOneShot = 0; + GenSymCountFormattedString = 0; + + // The EEPROM addresses for the `Make Persistent' op are assigned at + // int code generation time. + EepromAddrFree = 0; + + IntCodeLen = 0; + memset(IntCode, 0, sizeof(IntCode)); + + if(setjmp(CompileErrorBuf) != 0) { + return FALSE; + } + + Op(INT_SET_BIT, "$mcr"); + + int i; + for(i = 0; i < Prog.numRungs; i++) { + if(Prog.rungs[i]->count == 1 && + Prog.rungs[i]->contents[0].which == ELEM_COMMENT) + { + // nothing to do for this one + continue; + } + Comment(""); + Comment("start rung %d", i+1); + Op(INT_COPY_BIT_TO_BIT, "$rung_top", "$mcr"); + SimState(&(Prog.rungPowered[i]), "$rung_top"); + IntCodeFromCircuit(ELEM_SERIES_SUBCKT, Prog.rungs[i], "$rung_top"); + } + + return TRUE; +} |