mindyn.nim
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 |
{.pragma: rtl, exportc, dynlib, cdecl.} import lexbase, streams, critbits type MinTokenKind* = enum tkError, tkEof, tkString, tkInt, tkFloat, tkBracketLe, tkBracketRi, tkSymbol, tkTrue, tkFalse MinKind* = enum minInt, minFloat, minQuotation, minString, minSymbol, minBool MinEventKind* = enum ## enumeration of all events that may occur when parsing eMinError, ## an error ocurred during parsing eMinEof, ## end of file reached eMinString, ## a string literal eMinInt, ## an integer literal eMinFloat, ## a float literal eMinQuotationStart, ## start of an array: the ``(`` token eMinQuotationEnd ## start of an array: the ``)`` token MinParserError* = enum ## enumeration that lists all errors that can occur errNone, ## no error errInvalidToken, ## invalid token errStringExpected, ## string expected errBracketRiExpected, ## ``)`` expected errQuoteExpected, ## ``"`` or ``'`` expected errEOC_Expected, ## ``*/`` expected errEofExpected, ## EOF expected errExprExpected MinParserState* = enum stateEof, stateStart, stateQuotation, stateExpectValue MinParser* = object of BaseLexer a*: string token*: MinTokenKind state*: seq[MinParserState] kind*: MinEventKind err*: MinParserError filename*: string MinValue* = ref MinValueObject MinValueObject* = object line*: int column*: int filename*: string case kind*: MinKind of minInt: intVal*: BiggestInt of minFloat: floatVal*: BiggestFloat of minQuotation: qVal*: seq[MinValue] scope*: ref MinScope of minString: strVal*: string of minSymbol: symVal*: string of minBool: boolVal*: bool MinScope* = object symbols*: CritBitTree[MinOperator] sigils*: CritBitTree[MinOperator] parent*: ref MinScope name*: string stack*: MinStack MinOperatorProc* = proc (i: In) {.closure.} MinOperatorKind* = enum minProcOp minValOp MinOperator* = object sealed*: bool case kind*: MinOperatorKind of minProcOp: prc*: MinOperatorProc of minValOp: val*: MinValue MinStack* = seq[MinValue] In* = var MinInterpreter MinInterpreter* = object stack*: MinStack trace*: MinStack stackcopy*: MinStack pwd*: string scope*: ref MinScope parser*: MinParser currSym*: MinValue filename*: string evaluating*: bool MinParsingError* = ref object of ValueError MinUndefinedError* = ref object of ValueError MinEmptyStackError* = ref object of ValueError MinInvalidError* = ref object of ValueError MinOutOfBoundsError* = ref object of ValueError proc isSymbol*(s: MinValue): bool = return s.kind == minSymbol proc isQuotation*(s: MinValue): bool = return s.kind == minQuotation proc isString*(s: MinValue): bool = return s.kind == minString proc isFloat*(s: MinValue): bool = return s.kind == minFloat proc isInt*(s: MinValue): bool = return s.kind == minInt proc isNumber*(s: MinValue): bool = return s.kind == minInt or s.kind == minFloat proc isBool*(s: MinValue): bool = return s.kind == minBool proc isStringLike*(s: MinValue): bool = return s.isSymbol or s.isString or (s.isQuotation and s.qVal.len == 1 and s.qVal[0].isSymbol) proc isDictionary*(q: MinValue): bool = if not q.isQuotation: return false if q.qVal.len == 0: return true for val in q.qVal: if not val.isQuotation or val.qVal.len != 2 or not val.qVal[0].isString: return false return true proc newVal*(s: string): MinValue = return MinValue(kind: minString, strVal: s) proc newVal*(s: cstring): MinValue = return MinValue(kind: minString, strVal: $s) #proc newVal*(q: seq[MinValue], parentScope: ref MinScope): MinValue = # return MinValue(kind: minQuotation, qVal: q, scope: newScopeRef(parentScope)) proc newVal*(s: BiggestInt): MinValue = return MinValue(kind: minInt, intVal: s) proc newVal*(s: BiggestFloat): MinValue = return MinValue(kind: minFloat, floatVal: s) proc newVal*(s: bool): MinValue = return MinValue(kind: minBool, boolVal: s) proc newSym*(s: string): MinValue = return MinValue(kind: minSymbol, symVal: s) var define: proc(i: In): ref MinScope finalize: proc(scope: ref MinScope, name: string) symbol: proc(scope: ref MinScope, sym: string, p: MinOperatorProc) expect: proc(i: var MinInterpreter, elements: varargs[string]): seq[MinValue] push: proc(i: In, val: MinValue) proc setup*( defineProc: proc(i: In): ref MinScope, finalizeProc: proc(scope: ref MinScope, name: string), symbolProc: proc(scope: ref MinScope, sym: string, p: MinOperatorProc), expectProc: proc(i: var MinInterpreter, elements: varargs[string]): seq[MinValue], pushProc: proc(i: In, val: MinValue) ): string {.rtl.} = echo "Hello from lib" define = defineProc finalize = finalizeProc symbol = symbolProc expect = expectProc push = pushProc result = "the_lib" proc the_lib*(i: In) {.rtl.} = let def = i.define() def.symbol("myplus") do (i: In): let vals = i.expect("num", "num") let a = vals[0] let b = vals[1] if a.isInt: if b.isInt: i.push newVal(a.intVal + b.intVal) else: i.push newVal(a.intVal.float + b.floatVal) else: if b.isFloat: i.push newVal(a.floatVal + b.floatVal) else: i.push newVal(a.floatVal + b.intVal.float) def.finalize("dyn") |