Rev 7744 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 7564 | pavelyakov | 1 | |
| 7565 | pavelyakov | 2 | |
| 7745 | pavelyakov | 3 | |
| 4 | { |
||
| 7567 | pavelyakov | 5 | dword ret = 0; |
| 7745 | pavelyakov | 6 | dword arg = 0; |
| 7 | dword val = 0; |
||
| 8 | WHILE(count) |
||
| 9 | { |
||
| 10 | arg = DSDWORD[args]; |
||
| 11 | REPEAT1: |
||
| 12 | IF (DSDWORD[arg+4] == TSym) |
||
| 13 | { |
||
| 14 | arg = std_get(1, args); |
||
| 15 | goto REPEAT1; |
||
| 16 | } |
||
| 17 | IF (DSDWORD[arg+4] == TInt) |
||
| 18 | { |
||
| 19 | EAX = 5; |
||
| 20 | EBX = DSDWORD[arg]; |
||
| 21 | $int 0x40 |
||
| 22 | } |
||
| 23 | args+=4; |
||
| 24 | count--; |
||
| 25 | } |
||
| 26 | RETURN ret; |
||
| 27 | } |
||
| 7567 | pavelyakov | 28 | |
| 29 | |||
| 7564 | pavelyakov | 30 | { |
| 31 | dword name = 0; |
||
| 32 | dword value = 0; |
||
| 33 | WHILE(count > 0) |
||
| 7565 | pavelyakov | 34 | { |
| 7564 | pavelyakov | 35 | name = DSDWORD[args]; |
| 36 | IF (DSDWORD[name+4] == TSym) name = DSDWORD[name]; |
||
| 7744 | pavelyakov | 37 | ELSE |
| 38 | { |
||
| 39 | con_printf stdcall ("Error variable!"); |
||
| 40 | ExitProcess(); |
||
| 41 | } |
||
| 42 | args += 4; |
||
| 7564 | pavelyakov | 43 | value = DSDWORD[args]; |
| 44 | args += 4; |
||
| 45 | variables.set(name, value); |
||
| 46 | count -= 2; |
||
| 7565 | pavelyakov | 47 | } |
| 7564 | pavelyakov | 48 | } |
| 49 | |||
| 50 | |||
| 51 | { |
||
| 52 | dword name = 0; |
||
| 7744 | pavelyakov | 53 | IF(!count) RETURN 0; |
| 7565 | pavelyakov | 54 | name = DSDWORD[args]; |
| 7744 | pavelyakov | 55 | IF (DSDWORD[name+4] != TSym) |
| 56 | { |
||
| 57 | con_printf stdcall ("Error variable!"); |
||
| 58 | ExitProcess(); |
||
| 59 | } |
||
| 60 | RETURN variables.get(DSDWORD[name]); |
||
| 61 | } |
||
| 7564 | pavelyakov | 62 | |
| 63 | |||
| 7563 | pavelyakov | 64 | { |
| 65 | dword tmp = 0; |
||
| 66 | IF(!count) RETURN ""; |
||
| 7565 | pavelyakov | 67 | tmp = malloc(15); |
| 7563 | pavelyakov | 68 | itoa_(tmp,DSDWORD[args]); |
| 69 | RETURN tmp; |
||
| 70 | } |
||
| 71 | |||
| 72 | |||
| 7565 | pavelyakov | 73 | :dword std_add(dword count, args) |
| 7563 | pavelyakov | 74 | { |
| 75 | dword ret = 0; |
||
| 76 | WHILE(count) |
||
| 77 | { |
||
| 7562 | pavelyakov | 78 | ret += DSDWORD[args]; |
| 7563 | pavelyakov | 79 | args+=4; |
| 80 | count--; |
||
| 81 | } |
||
| 7562 | pavelyakov | 82 | RETURN ret; |
| 7563 | pavelyakov | 83 | } |
| 84 | |||
| 85 | |||
| 7745 | pavelyakov | 86 | { |
| 87 | IF(initConsole) con_exit stdcall (1); |
||
| 88 | ExitProcess(); |
||
| 89 | } |
||
| 90 | |||
| 91 | |||
| 7563 | pavelyakov | 92 | { |
| 93 | dword ret = 0; |
||
| 94 | IF(count) |
||
| 95 | { |
||
| 96 | ret = DSDWORD[args]; |
||
| 97 | count--; |
||
| 98 | args+=4; |
||
| 99 | } |
||
| 7562 | pavelyakov | 100 | WHILE(count) |
| 7563 | pavelyakov | 101 | { |
| 7562 | pavelyakov | 102 | ret -= DSDWORD[args]; |
| 7563 | pavelyakov | 103 | args += 4; |
| 7565 | pavelyakov | 104 | count--; |
| 105 | } |
||
| 106 | RETURN ret; |
||
| 107 | } |
||
| 108 | |||
| 109 | |||
| 7745 | pavelyakov | 110 | { |
| 111 | dword ret = 0; |
||
| 112 | dword arg = 0; |
||
| 113 | dword val = 0; |
||
| 114 | ret = malloc(TLen); |
||
| 115 | DSDWORD[ret] = "nil"; |
||
| 116 | DSDWORD[ret+4] = TStr; |
||
| 117 | WHILE(count) |
||
| 118 | { |
||
| 119 | arg = DSDWORD[args]; |
||
| 120 | REPEAT1: |
||
| 121 | IF (DSDWORD[arg+4] == TSym) |
||
| 122 | { |
||
| 123 | arg = std_get(1, args); |
||
| 124 | goto REPEAT1; |
||
| 125 | } |
||
| 126 | switch (DSDWORD[arg+4]) |
||
| 127 | { |
||
| 128 | case TStr: |
||
| 129 | DSDWORD[ret] = "string"; |
||
| 130 | break; |
||
| 131 | case TInt: |
||
| 132 | DSDWORD[ret] = "integer"; |
||
| 133 | break; |
||
| 134 | } |
||
| 135 | args+=4; |
||
| 136 | count--; |
||
| 137 | } |
||
| 138 | RETURN ret; |
||
| 139 | } |
||
| 140 | |||
| 141 | |||
| 7565 | pavelyakov | 142 | :dword std_print(dword count, args) |
| 143 | { |
||
| 144 | dword ret = 0; |
||
| 145 | dword arg = 0; |
||
| 7744 | pavelyakov | 146 | dword val = 0; |
| 147 | consoleInit(); |
||
| 7566 | pavelyakov | 148 | IF (!count) con_printf stdcall ("nil"); |
| 7744 | pavelyakov | 149 | WHILE(count) |
| 7565 | pavelyakov | 150 | { |
| 151 | arg = DSDWORD[args]; |
||
| 7744 | pavelyakov | 152 | REPEAT1: |
| 153 | IF (DSDWORD[arg+4] == TInt) val = itoa(DSDWORD[arg]); |
||
| 154 | ELSE IF (DSDWORD[arg+4] == TStr) val = DSDWORD[arg]; |
||
| 155 | ELSE IF (DSDWORD[arg+4] == TSym) |
||
| 156 | { |
||
| 157 | arg = std_get(1, args); |
||
| 158 | goto REPEAT1; |
||
| 159 | } |
||
| 160 | IF(!arg) con_printf stdcall ("nil"); |
||
| 161 | ELSE con_printf stdcall (val); |
||
| 162 | args+=4; |
||
| 7563 | pavelyakov | 163 | count--; |
| 164 | } |
||
| 7562 | pavelyakov | 165 | RETURN ret; |
| 7563 | pavelyakov | 166 | } |
| 167 | |||
| 168 | |||
| 7744 | pavelyakov | 169 | { |
| 7565 | pavelyakov | 170 | dword ret = 0; |
| 7744 | pavelyakov | 171 | dword arg = 0; |
| 172 | dword val = 0; |
||
| 173 | ret = malloc(TLen); |
||
| 174 | DSDWORD[ret] = 0; |
||
| 175 | DSDWORD[ret+4] = TInt; |
||
| 176 | WHILE(count) |
||
| 7565 | pavelyakov | 177 | { |
| 178 | arg = DSDWORD[args]; |
||
| 7744 | pavelyakov | 179 | REPEAT1: |
| 180 | IF (DSDWORD[arg+4] == TStr) val = DSDWORD[arg]; |
||
| 181 | ELSE IF (DSDWORD[arg+4] == TSym) |
||
| 182 | { |
||
| 183 | arg = std_get(1, args); |
||
| 184 | goto REPEAT1; |
||
| 185 | } |
||
| 186 | ELSE return ret; |
||
| 187 | DSDWORD[ret] += DSDWORD[arg+8]; |
||
| 188 | args+=4; |
||
| 7565 | pavelyakov | 189 | count--; |
| 190 | } |
||
| 191 | RETURN ret; |
||
| 7744 | pavelyakov | 192 | } |
| 193 | |||
| 194 | |||
| 195 | { |
||
| 196 | dword ret = 0; |
||
| 197 | dword arg = 0; |
||
| 198 | dword val = 0; |
||
| 199 | dword tmp = 0; |
||
| 200 | dword x = 0; |
||
| 201 | dword y = 0; |
||
| 202 | byte start = 0; |
||
| 203 | ret = malloc(TLen); |
||
| 204 | DSDWORD[ret] = 0; |
||
| 205 | DSDWORD[ret+4] = TInt; |
||
| 206 | IF (!count) return ret; |
||
| 207 | while(count) |
||
| 208 | { |
||
| 209 | arg = DSDWORD[args]; |
||
| 210 | REPEAT2: |
||
| 211 | IF (DSDWORD[arg+4] == TSym) |
||
| 212 | { |
||
| 213 | arg = std_get(1, args); |
||
| 214 | goto REPEAT2; |
||
| 215 | } |
||
| 216 | IF (!start) |
||
| 217 | { |
||
| 218 | start = 1; |
||
| 219 | tmp = arg; |
||
| 220 | args+=4; |
||
| 221 | count--; |
||
| 222 | continue; |
||
| 223 | } |
||
| 224 | IF (DSDWORD[tmp+4] != DSDWORD[arg+4]) return ret; |
||
| 225 | IF (DSDWORD[tmp+4] == TInt) |
||
| 226 | { |
||
| 227 | IF (DSDWORD[tmp] != DSDWORD[arg]) return ret; |
||
| 228 | } |
||
| 229 | ELSE IF (DSDWORD[tmp+4] == TStr) |
||
| 230 | { |
||
| 231 | /*IF (!DSDWORD[tmp+8]) DSDWORD[tmp+8] = crc32(DSDWORD[tmp]); |
||
| 232 | IF (!DSDWORD[arg+8]) DSDWORD[arg+8] = crc32(DSDWORD[arg]); |
||
| 233 | IF (DSDWORD[tmp+8] != DSDWORD[arg+8]) return ret;*/ |
||
| 234 | IF (strcmp(DSDWORD[tmp], DSDWORD[arg])) return ret; |
||
| 235 | } |
||
| 236 | args+=4; |
||
| 237 | count--; |
||
| 238 | } |
||
| 239 | DSDWORD[ret] = 1; |
||
| 240 | return ret; |
||
| 241 | } |
||
| 242 | |||
| 243 | |||
| 244 | { |
||
| 245 | dword buf = 0; |
||
| 246 | consoleInit(); |
||
| 247 | buf = malloc(100); |
||
| 248 | IF (count) std_print(count, args); |
||
| 249 | con_gets stdcall(buf, 100); |
||
| 7565 | pavelyakov | 250 | EDX = malloc(TLen); |
| 7744 | pavelyakov | 251 | DSDWORD[EDX] = buf; |
| 252 | DSDWORD[EDX+4] = TStr; |
||
| 253 | RETURN EDX; |
||
| 254 | } |
||
| 7565 | pavelyakov | 255 | |
| 256 | |||
| 7563 | pavelyakov | 257 | { |
| 258 | functions.init(100); |
||
| 259 | |||
| 260 | |||
| 261 | functions.set("print", #std_print); |
||
| 7565 | pavelyakov | 262 | functions.set("input", #std_input); |
| 263 | |||
| 7563 | pavelyakov | 264 | |
| 265 | functions.set("str", #std_str); |
||
| 266 | functions.set("len", #std_len); |
||
| 7744 | pavelyakov | 267 | |
| 7563 | pavelyakov | 268 | |
| 269 | functions.set("exit", #std_exit); |
||
| 7567 | pavelyakov | 270 | |
| 7563 | pavelyakov | 271 | |
| 272 | functions.set("+", #std_add); |
||
| 273 | functions.set("-", #std_sub); |
||
| 274 | functions.set("==", #std_cmp); |
||
| 7744 | pavelyakov | 275 | |
| 7563 | pavelyakov | 276 | |
| 7564 | pavelyakov | 277 | functions.set("set", #std_set); |
| 278 | functions.set("get", #std_get); |
||
| 279 | functions.set("type", #std_type); |
||
| 7745 | pavelyakov | 280 | functions.set("sleep", #std_sleep); |
| 281 | |||
| 282 | |||
| 7564 | pavelyakov | 283 | |
| 7563 | pavelyakov | 284 | } |
| 285 | |||
| 286 | |||
| 287 | { |
||
| 288 | functions.get(name); |
||
| 289 | IF(EAX) RETURN EAX(count, args); |
||
| 7564 | pavelyakov | 290 | RETURN 0; |
| 7563 | pavelyakov | 291 | } |
| 7564 | pavelyakov | 292 |