source: trunk/lib/ubasic/ubasic.c @ 846

Revision 846, 62.3 KB checked in by reyalp, 3 years ago (diff)

fix ubasic test program
  • Property svn:eol-style set to native
Line 
1/*
2 * Copyright (c) 2006, Adam Dunkels
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the author nor the names of its contributors
14 *    may be used to endorse or promote products derived from this software
15 *    without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 */
30
31#if DEBUG
32#define DEBUG_PRINTF(...)  printf(__VA_ARGS__)
33#else
34#define DEBUG_PRINTF(...)
35#endif
36
37#ifdef UBASIC_TEST
38#include "../../include/ubasic.h"
39#include "../../include/platform.h"
40#include "../../include/script.h"
41#include "../../include/shot_histogram.h"
42#include "../../include/levent.h"
43#include <string.h>
44#include <time.h>
45#include <fcntl.h>
46#include <io.h>
47#include <stdlib.h> /* rand,srand */
48#else
49#include "ubasic.h"
50#include "platform.h"
51#include "script.h"
52#include "camera.h"
53#include "shot_histogram.h"
54#include "stdlib.h"
55#include "levent.h"
56#endif
57#include "tokenizer.h"
58
59
60#include "../../include/conf.h"
61
62#include "camera_functions.h"
63
64
65#define INCLUDE_OLD_GET__SYNTAX
66
67#ifdef DEBUG
68#include <stdio.h>
69#endif
70
71static char const *program_ptr;
72#define MAX_STRINGLEN 40
73static char string[MAX_STRINGLEN];
74
75#define MAX_GOSUB_STACK_DEPTH 10
76static short gosub_stack[MAX_GOSUB_STACK_DEPTH];
77static int gosub_stack_ptr;
78
79#define MAX_IF_STACK_DEPTH 4
80static short if_stack[MAX_IF_STACK_DEPTH];
81static int if_stack_ptr;
82
83struct select_state {
84  int select_value;
85  short case_run;
86};
87#define MAX_SELECT_STACK_DEPTH 4
88static struct select_state select_stack[MAX_SELECT_STACK_DEPTH];
89static int select_stack_ptr;
90
91#define MAX_WHILE_STACK_DEPTH 4
92static short while_stack[MAX_WHILE_STACK_DEPTH];
93static int while_stack_ptr;
94
95#define MAX_DO_STACK_DEPTH 4
96static short do_stack[MAX_DO_STACK_DEPTH];
97static int do_stack_ptr;
98
99struct for_state {
100  short line_after_for;
101  short for_variable;
102  int to;
103  int step;
104};
105#define MAX_FOR_STACK_DEPTH 4
106static struct for_state for_stack[MAX_FOR_STACK_DEPTH];
107static int for_stack_ptr;
108
109#define MAX_VARNUM 52
110static int variables[MAX_VARNUM];
111
112static int ended;
113
114static int expr(void);
115static void line_statement(void);
116static void statement(void);
117static int relation(void);
118
119int ubasic_error;
120const char *ubasic_errstrings[UBASIC_E_ENDMARK] =
121{
122    "No err",
123    "Parse err",
124    "Unk stmt",
125    "Unk key",
126    "Unk label",
127    "Stack ful",
128    "bad return",
129    "Unk err"
130};
131
132/*---------------------------------------------------------------------------*/
133int
134ubasic_linenumber()
135{
136  return tokenizer_line_number();
137}
138
139/*---------------------------------------------------------------------------*/
140void
141ubasic_init(const char *program)
142{
143  program_ptr = program;
144  for_stack_ptr = gosub_stack_ptr = while_stack_ptr = do_stack_ptr = if_stack_ptr = 0;
145  tokenizer_init(program);
146  ended = 0;
147  ubasic_error = UBASIC_E_NONE;
148}
149/*---------------------------------------------------------------------------*/
150static void
151accept(int token)
152{
153  if(token != tokenizer_token()) {
154    DEBUG_PRINTF("Token not what was expected (expected %d, got %d)\n",
155                 token, tokenizer_token());
156    tokenizer_error_print();
157     tokenizer_next();
158     ended = 1;
159     ubasic_error = UBASIC_E_PARSE;
160     return;
161  }
162  DEBUG_PRINTF("Expected %d, got it\n", token);
163  tokenizer_next();
164}
165/*---------------------------------------------------------------------------*/
166static void
167accept_cr()
168{
169    while(tokenizer_token() != TOKENIZER_CR &&
170            tokenizer_token() != TOKENIZER_ENDOFINPUT)
171      tokenizer_next();
172    accept(TOKENIZER_CR);
173}
174/*---------------------------------------------------------------------------*/
175static int
176varfactor(void)
177{
178  int r;
179  DEBUG_PRINTF("varfactor: obtaining %d from variable %d\n", variables[tokenizer_variable_num()], tokenizer_variable_num());
180  r = ubasic_get_variable(tokenizer_variable_num());
181  accept(TOKENIZER_VARIABLE);
182  return r;
183}
184/*---------------------------------------------------------------------------*/
185static int
186factor(void)
187{
188  int r = 0;
189
190  DEBUG_PRINTF("factor: token %d\n", tokenizer_token());
191  switch(tokenizer_token()) {
192  case TOKENIZER_NUMBER:
193    r = tokenizer_num();
194    DEBUG_PRINTF("factor: number %d\n", r);
195    accept(TOKENIZER_NUMBER);
196    break;
197  case TOKENIZER_LEFTPAREN:
198    accept(TOKENIZER_LEFTPAREN);
199    r = relation();
200    accept(TOKENIZER_RIGHTPAREN);
201    break;
202  case TOKENIZER_PLUS:
203    accept(TOKENIZER_PLUS);
204    r = factor();
205    break;
206  case TOKENIZER_MINUS:
207    accept(TOKENIZER_MINUS);
208    r = - factor();
209    break;
210  case TOKENIZER_LNOT:
211    accept(TOKENIZER_LNOT);
212    r = ! relation();
213    break;
214case TOKENIZER_GET_VBATT:
215    accept(TOKENIZER_GET_VBATT);
216    r = (unsigned short) stat_get_vbatt();
217    break;
218 case TOKENIZER_GET_DAY_SECONDS:
219    accept(TOKENIZER_GET_DAY_SECONDS);
220    r = shooting_get_day_seconds();
221    break;
222 case TOKENIZER_GET_TICK_COUNT:
223    accept(TOKENIZER_GET_TICK_COUNT);
224    r = shooting_get_tick_count();     
225   break;
226 case TOKENIZER_GET_MODE:
227    accept(TOKENIZER_GET_MODE);
228    int m=mode_get()&MODE_SHOOTING_MASK;
229    int mode_video=MODE_IS_VIDEO(m);
230    if ((mode_get()&MODE_MASK) != MODE_PLAY) r = 0;
231    if ((mode_get()&MODE_MASK) == MODE_PLAY) r = 1;
232    if (((mode_get()&MODE_MASK) != MODE_PLAY) && mode_video) r = 2;
233   break;
234 case TOKENIZER_GET_RAW_NR:
235    accept(TOKENIZER_GET_RAW_NR);
236    r = ubasic_camera_get_nr();     
237    break;
238 case TOKENIZER_IS_KEY:
239    accept(TOKENIZER_IS_KEY);
240    tokenizer_string(string, sizeof(string));
241    tokenizer_next();
242    r = ubasic_camera_is_clicked(string);
243    break;
244case TOKENIZER_SCRIPT_AUTOSTARTED:
245    accept(TOKENIZER_SCRIPT_AUTOSTARTED);
246    r = ubasic_camera_script_autostart();
247    break;
248case TOKENIZER_GET_SCRIPT_AUTOSTART:
249    accept(TOKENIZER_GET_SCRIPT_AUTOSTART);
250#ifdef UBASIC_TEST
251        r = 0;
252#else
253    r = conf.script_startup;
254#endif
255    break;
256case TOKENIZER_GET_USB_POWER:
257    accept(TOKENIZER_GET_USB_POWER);
258    r = get_usb_power(0);     
259    break;
260case TOKENIZER_GET_EXP_COUNT:
261    accept(TOKENIZER_GET_EXP_COUNT);
262    r = get_exposure_counter();
263    break;
264case TOKENIZER_IS_PRESSED:
265    accept(TOKENIZER_IS_PRESSED);
266    tokenizer_string(string, sizeof(string));
267    tokenizer_next();
268    r = ubasic_camera_is_pressed(string);
269    break;
270  case TOKENIZER_RANDOM:
271    accept(TOKENIZER_RANDOM);
272    int min = expr();
273    int max = expr();
274    srand((int)shooting_get_bv96()+(unsigned short)stat_get_vbatt()+get_tick_count());
275    ubasic_camera_sleep(rand()%10);
276    r = min + rand()%(max-min+1);
277  break;
278  case TOKENIZER_GET_MOVIE_STATUS:
279    accept(TOKENIZER_GET_MOVIE_STATUS);
280    r = movie_status;
281   break;
282  case TOKENIZER_GET_PLATFORM_ID:
283    accept(TOKENIZER_GET_PLATFORM_ID);
284    r = PLATFORMID;
285   break;
286  case TOKENIZER_GET_DRIVE_MODE:
287    accept(TOKENIZER_GET_DRIVE_MODE);
288    r = shooting_get_drive_mode();
289   break;
290  case TOKENIZER_GET_FOCUS_MODE:
291    accept(TOKENIZER_GET_FOCUS_MODE);
292    r = shooting_get_prop(PROPCASE_FOCUS_MODE);
293   break;
294        case TOKENIZER_GET_DISPLAY_MODE:
295    accept(TOKENIZER_GET_DISPLAY_MODE);
296    r = shooting_get_prop(PROPCASE_DISPLAY_MODE);
297   break;
298  case TOKENIZER_GET_FLASH_MODE:
299    accept(TOKENIZER_GET_FLASH_MODE);
300    r = shooting_get_prop(PROPCASE_FLASH_MODE);
301   break;
302  case TOKENIZER_GET_SHOOTING:
303    accept(TOKENIZER_GET_SHOOTING);
304    r = shooting_get_prop(PROPCASE_SHOOTING);
305   break;
306  case TOKENIZER_GET_FLASH_READY:
307    accept(TOKENIZER_GET_FLASH_READY);
308    r = shooting_get_prop(PROPCASE_IS_FLASH_READY);
309   break;
310  case TOKENIZER_GET_IS_MODE:
311    accept(TOKENIZER_GET_IS_MODE);
312    r = shooting_get_prop(PROPCASE_IS_MODE);
313   break;
314  case TOKENIZER_GET_EV:
315    accept(TOKENIZER_GET_EV);
316    r = shooting_get_prop(PROPCASE_EV_CORRECTION_1);
317   break;
318  case TOKENIZER_GET_RESOLUTION:
319    accept(TOKENIZER_GET_RESOLUTION);
320    r = shooting_get_prop(PROPCASE_RESOLUTION);
321   break;
322  case TOKENIZER_GET_QUALITY:
323    accept(TOKENIZER_GET_QUALITY);
324    r = shooting_get_prop(PROPCASE_QUALITY);
325   break;
326  case TOKENIZER_GET_ORIENTATION_SENSOR:
327    accept(TOKENIZER_GET_ORIENTATION_SENSOR);
328    r = shooting_get_prop(PROPCASE_ORIENTATION_SENSOR);
329   break;
330  case TOKENIZER_GET_ZOOM_STEPS:
331    accept(TOKENIZER_GET_ZOOM_STEPS);
332    r = zoom_points;
333   break;
334  case TOKENIZER_GET_ND_PRESENT:
335    accept(TOKENIZER_GET_ND_PRESENT);
336    #if !CAM_HAS_ND_FILTER
337    r = 0;
338    #endif
339    #if CAM_HAS_ND_FILTER && !CAM_HAS_IRIS_DIAPHRAGM
340    r = 1;
341    #endif
342    #if CAM_HAS_ND_FILTER && CAM_HAS_IRIS_DIAPHRAGM
343    r = 2;
344    #endif
345   break;
346  case TOKENIZER_GET_PROPSET:
347    accept(TOKENIZER_GET_PROPSET);
348    #if CAM_PROPSET == 1
349    r = 1;
350    #elif CAM_PROPSET == 2
351    r = 2;
352    #endif
353   break;
354  case TOKENIZER_GET_TV96:
355    accept(TOKENIZER_GET_TV96);
356    r = shooting_get_tv96();
357    break;
358  case TOKENIZER_GET_USER_TV96:
359    accept(TOKENIZER_GET_USER_TV96);
360    r = shooting_get_user_tv96();
361    break;   
362  case TOKENIZER_GET_USER_TV_ID:
363    accept(TOKENIZER_GET_USER_TV_ID);
364    r = shooting_get_user_tv_id();
365    break;
366  case TOKENIZER_GET_AV96:
367    accept(TOKENIZER_GET_AV96);
368    r = shooting_get_av96();
369    break; 
370  case TOKENIZER_GET_USER_AV96:
371    accept(TOKENIZER_GET_USER_AV96);
372    r = shooting_get_user_av96();
373    break;   
374  case TOKENIZER_GET_USER_AV_ID:
375    accept(TOKENIZER_GET_USER_AV_ID);
376    r = shooting_get_user_av_id();
377    break;
378  case TOKENIZER_GET_ZOOM:
379    accept(TOKENIZER_GET_ZOOM);
380    r = shooting_get_zoom();
381    break;
382  case TOKENIZER_GET_FOCUS:
383    accept(TOKENIZER_GET_FOCUS);
384    r = shooting_get_subject_distance();
385    break;
386  case TOKENIZER_GET_NEAR_LIMIT:
387    accept(TOKENIZER_GET_NEAR_LIMIT);
388    r = shooting_get_near_limit_of_acceptable_sharpness();
389    break;
390  case TOKENIZER_GET_FAR_LIMIT:
391    accept(TOKENIZER_GET_FAR_LIMIT);
392    r = shooting_get_far_limit_of_acceptable_sharpness();
393    break; 
394   case TOKENIZER_GET_DOF:
395    accept(TOKENIZER_GET_DOF);
396    r = shooting_get_depth_of_field();
397    break;
398  case TOKENIZER_GET_HYPERFOCAL_DIST:
399    accept(TOKENIZER_GET_HYPERFOCAL_DIST);
400    r = shooting_get_hyperfocal_distance();
401    break; 
402  case TOKENIZER_GET_ISO_MARKET:
403    accept(TOKENIZER_GET_ISO_MARKET);
404    r = (int)shooting_get_iso_market();
405    break;
406  case TOKENIZER_GET_ISO_REAL:
407    accept(TOKENIZER_GET_ISO_REAL);
408    r = (int)shooting_get_iso_real();
409    break;
410  case TOKENIZER_GET_BV96:
411    accept(TOKENIZER_GET_BV96);
412    r = (int)shooting_get_bv96();
413    break; 
414  case TOKENIZER_GET_SV96:
415    accept(TOKENIZER_GET_SV96);
416    r = (int)shooting_get_sv96();
417    break;   
418  case TOKENIZER_GET_ISO_MODE:
419    accept(TOKENIZER_GET_ISO_MODE);
420    r = shooting_get_iso_mode();
421    break;
422  case TOKENIZER_GET_DISK_SIZE:
423    accept(TOKENIZER_GET_DISK_SIZE);
424    r = GetTotalCardSpaceKb();
425    break;
426  case TOKENIZER_GET_FREE_DISK_SPACE:
427    accept(TOKENIZER_GET_FREE_DISK_SPACE);
428    r = GetFreeCardSpaceKb();
429    break;
430
431  case TOKENIZER_GET_JPG_COUNT:
432    accept(TOKENIZER_GET_JPG_COUNT);
433    r = GetJpgCount();
434    break;
435  case TOKENIZER_GET_VIDEO_BUTTON:
436    accept(TOKENIZER_GET_VIDEO_BUTTON);
437    #if CAM_HAS_VIDEO_BUTTON
438    r = 1;
439    #else
440    r = 0;
441    #endif
442    break;
443  case TOKENIZER_GET_RAW_COUNT:
444    accept(TOKENIZER_GET_RAW_COUNT);
445    r = GetRawCount();
446    break;
447  case TOKENIZER_GET_PROP:
448    accept(TOKENIZER_GET_PROP);
449    int var = expr();
450    r = shooting_get_prop(var);
451    break;
452  case TOKENIZER_GET_HISTO_RANGE:
453    accept(TOKENIZER_GET_HISTO_RANGE);
454    int from = expr();
455    int to = expr();
456    if (shot_histogram_isenabled()) r = (unsigned short)shot_histogram_get_range(from, to);
457    else r = -1;
458    break;
459  case TOKENIZER_GET_TEMPERATURE:
460    accept(TOKENIZER_GET_TEMPERATURE);
461    int temp = expr();
462    switch (temp)
463    {
464        case 0:
465                r = get_optical_temp();
466                break;
467        case 1:
468                r = get_ccd_temp();
469                break;
470        case 2:
471                r = get_battery_temp();
472                break;
473                default: // do something sane if given a bad index
474                        r = 0;
475  }
476    break;
477  case TOKENIZER_GET_TIME: {
478    accept(TOKENIZER_GET_TIME);
479    unsigned long t2 = time(NULL);
480    int tmode = expr();
481    static struct tm *ttm;
482    ttm = localtime(&t2);
483    if (tmode==0) r = ttm->tm_sec;
484    else if (tmode==1) r = ttm->tm_min;
485    else if (tmode==2) r = ttm->tm_hour;
486    else if (tmode==3) r = ttm->tm_mday;
487    else if (tmode==4) r = ttm->tm_mon+1;
488    else if (tmode==5) r = 1900+ttm->tm_year;
489    break;
490 }
491 case TOKENIZER_GET_RAW:
492    accept(TOKENIZER_GET_RAW);
493#ifdef UBASIC_TEST
494        r = 1;
495#else
496    r = conf.save_raw;     
497#endif
498    break;
499  default:
500    r = varfactor();
501    break;
502  }
503  return r;
504}
505/*---------------------------------------------------------------------------*/
506static int
507term(void)
508{
509  int f1, f2;
510  int op;
511
512  f1 = factor();
513  op = tokenizer_token();
514  DEBUG_PRINTF("term: token %d\n", op);
515  while(op == TOKENIZER_ASTR ||
516        op == TOKENIZER_SLASH ||
517        op == TOKENIZER_LT ||
518        op == TOKENIZER_GT ||
519        op == TOKENIZER_GE ||
520        op == TOKENIZER_LE ||
521        op == TOKENIZER_NE ||
522        op == TOKENIZER_EQ ||
523        op == TOKENIZER_XOR ||
524        op == TOKENIZER_OR ||
525        op == TOKENIZER_MOD) {
526    tokenizer_next();
527    f2 = factor();
528    DEBUG_PRINTF("term: %d %d %d\n", f1, op, f2);
529    switch(op) {
530    case TOKENIZER_ASTR:
531      f1 = f1 * f2;
532      break;
533    case TOKENIZER_SLASH:
534      f1 = f1 / f2;
535      break;
536    case TOKENIZER_MOD:
537      f1 = f1 % f2;
538      break;
539    case TOKENIZER_LT:
540      f1 = f1 < f2;
541      break;
542    case TOKENIZER_GT:
543      f1 = f1 > f2;
544      break;
545    case TOKENIZER_EQ:
546      f1 = f1 == f2;
547      break;
548    case TOKENIZER_NE:
549      f1 = f1 != f2;
550      break;
551    case TOKENIZER_LE:
552      f1 = f1 <= f2;
553      break;
554    case TOKENIZER_GE:
555      f1 = f1 >= f2;
556      break;
557    case TOKENIZER_OR:
558      f1 = f1 | f2;
559      break;
560    case TOKENIZER_XOR:
561      f1 = f1 ^ f2;
562      break;
563    }
564    op = tokenizer_token();
565  }
566  DEBUG_PRINTF("term: %d\n", f1);
567  return f1;
568}
569/*---------------------------------------------------------------------------*/
570static int
571expr(void)
572{
573  int t1, t2;
574  int op;
575 
576  t1 = term();
577  op = tokenizer_token();
578  DEBUG_PRINTF("expr: token %d\n", op);
579  while(op == TOKENIZER_PLUS ||
580        op == TOKENIZER_MINUS ||
581        op == TOKENIZER_AND ||
582        op == TOKENIZER_LOR ||
583        op == TOKENIZER_XOR) {
584    tokenizer_next();
585    t2 = term();
586    DEBUG_PRINTF("expr: %d %d %d\n", t1, op, t2);
587    switch(op) {
588    case TOKENIZER_PLUS:
589      t1 = t1 + t2;
590      break;
591    case TOKENIZER_MINUS:
592      t1 = t1 - t2;
593      break;
594    case TOKENIZER_AND:
595      t1 = t1 & t2;
596      break;
597    case TOKENIZER_LOR:
598      t1 = t1 || t2;
599      break;
600    }
601    op = tokenizer_token();
602  }
603  DEBUG_PRINTF("expr: %d\n", t1);
604  return t1;
605}
606/*---------------------------------------------------------------------------*/
607static int
608relation(void)
609{
610  int r1, r2;
611  int op;
612 
613  r1 = expr();
614  op = tokenizer_token();
615  DEBUG_PRINTF("relation: token %d\n", op);
616  while(op == TOKENIZER_LAND) {
617    tokenizer_next();
618    r2 = expr();
619    DEBUG_PRINTF("relation: %d %d %d\n", r1, op, r2);
620    switch(op) {
621    case TOKENIZER_LAND:
622      r1 = r1 && r2;
623      break;
624    }
625    op = tokenizer_token();
626  }
627  return r1;
628}
629
630#if 0
631/*---------------------------------------------------------------------------*/
632static void
633jump_linenum(int linenum)
634{
635  tokenizer_init(program_ptr);
636  while(tokenizer_num() != linenum) {
637    do {
638      do {
639        tokenizer_next();
640      } while(tokenizer_token() != TOKENIZER_CR &&
641              tokenizer_token() != TOKENIZER_ENDOFINPUT);
642      if(tokenizer_token() == TOKENIZER_CR) {
643        tokenizer_next();
644      }
645    } while(tokenizer_token() != TOKENIZER_NUMBER);
646    DEBUG_PRINTF("jump_linenum: Found line %d\n", tokenizer_num());
647  }
648}
649#endif
650
651/*---------------------------------------------------------------------------*/
652static void
653jump_line(int linenum)
654{
655  tokenizer_init(program_ptr);
656  while(tokenizer_line_number() != linenum) {
657    tokenizer_next();
658  }
659  /* swallow the CR that would be read next */
660  accept(TOKENIZER_CR);
661
662}
663/*---------------------------------------------------------------------------*/
664// TODO: error handling?
665int
666jump_label(char * label)
667{
668  char currLabel[MAX_STRINGLEN];
669  tokenizer_init(program_ptr);
670  currLabel[0] = 0;
671  while(tokenizer_token() != TOKENIZER_ENDOFINPUT) {
672    tokenizer_next();
673    if (tokenizer_token() == TOKENIZER_LABEL) {
674      tokenizer_label(currLabel, sizeof(currLabel));
675      tokenizer_next();
676      if(strcmp(label, currLabel) == 0) {
677        accept(TOKENIZER_CR);
678        DEBUG_PRINTF("jump_linenum: Found line %d\n", tokenizer_line_number());
679        break;
680      }
681    }
682  }
683  if (tokenizer_token() == TOKENIZER_ENDOFINPUT) {
684    if (state_kbd_script_run == 1) { 
685      DEBUG_PRINTF("Label %s not found", label);
686      ubasic_error = UBASIC_E_UNK_LABEL;
687    }
688      return 0;
689  } else {
690      return 1;
691  }
692}
693/*---------------------------------------------------------------------------*/
694static void
695goto_statement(void)
696{
697  accept(TOKENIZER_GOTO);
698  if(tokenizer_token() == TOKENIZER_STRING) {
699    tokenizer_string(string, sizeof(string));
700    tokenizer_next();
701    jump_label(string);
702  } else {
703    DEBUG_PRINTF("ubasic.c: goto_statement(): no label specified\n");
704    ended = 1;
705    ubasic_error = UBASIC_E_UNK_LABEL;
706  }
707}
708/*---------------------------------------------------------------------------*/
709static void
710print_screen_statement(void)
711{
712  int val;
713  accept(TOKENIZER_PRINT_SCREEN);
714  val = expr();
715  accept(TOKENIZER_CR);
716  script_print_screen_statement(val);
717}
718/*---------------------------------------------------------------------------*/
719static void
720print_statement(void)
721{
722  static char buf[128];
723
724  buf[0]=0;
725  accept(TOKENIZER_PRINT);
726  do {
727    DEBUG_PRINTF("Print loop\n");
728    if(tokenizer_token() == TOKENIZER_STRING) {
729      tokenizer_string(string, sizeof(string));
730      sprintf(buf+strlen(buf), "%s", string);
731      tokenizer_next();
732    } else if(tokenizer_token() == TOKENIZER_COMMA) {
733      strcat(buf, " ");
734      tokenizer_next();
735    } else if(tokenizer_token() == TOKENIZER_SEMICOLON) {
736      tokenizer_next();
737    } else {
738      sprintf(buf+strlen(buf), "%d", expr());
739    }
740  } while(tokenizer_token() != TOKENIZER_CR && tokenizer_token() != TOKENIZER_ENDOFINPUT && tokenizer_token() != TOKENIZER_ELSE);
741  script_console_add_line(buf);
742  DEBUG_PRINTF("End of print\n");
743  accept_cr();
744}
745/*---------------------------------------------------------------------------*/
746static void
747if_statement(void)
748{
749  int r, else_cntr,endif_cntr;
750 
751  accept(TOKENIZER_IF);
752
753  r = relation(); /*relation(); */
754 // printf("if_statement: relation %d\n", r);
755  accept(TOKENIZER_THEN);
756  if (tokenizer_token() == TOKENIZER_CR) { 
757        if(if_stack_ptr < MAX_IF_STACK_DEPTH) {
758         if_stack[if_stack_ptr] = r;
759         if_stack_ptr++;
760        }
761          accept(TOKENIZER_CR);
762          if(r) {
763                return;
764          }
765          else {
766                else_cntr=endif_cntr=0;
767                  tokenizer_next();       
768                while(((tokenizer_token() != TOKENIZER_ELSE &&  tokenizer_token() != TOKENIZER_ENDIF)
769                       || else_cntr || endif_cntr) && tokenizer_token() != TOKENIZER_ENDOFINPUT){
770                  if( tokenizer_token() == TOKENIZER_IF) {else_cntr+=1;endif_cntr+=1;}             
771                  if( tokenizer_token() == TOKENIZER_ELSE) {
772                          else_cntr--;           
773                  }
774                  if( tokenizer_token() == TOKENIZER_ENDIF)  {
775                    endif_cntr--;
776            if (endif_cntr != else_cntr) else_cntr--;
777                  }   
778                  tokenizer_next();                                                         
779                 }
780            if(tokenizer_token() == TOKENIZER_ELSE) {
781                return;
782                }
783          }                                                 
784          accept(TOKENIZER_ENDIF);
785          accept(TOKENIZER_CR);                       
786          if(if_stack_ptr > 0) {
787             if_stack_ptr--;
788          }
789  }else {
790          if(r) {
791            statement();
792          } else {
793            do {
794              tokenizer_next();
795            } while(tokenizer_token() != TOKENIZER_ELSE &&
796                    tokenizer_token() != TOKENIZER_CR &&
797                    tokenizer_token() != TOKENIZER_ENDOFINPUT);
798            if(tokenizer_token() == TOKENIZER_ELSE) {
799              tokenizer_next();
800              statement();
801            } else if(tokenizer_token() == TOKENIZER_CR) {
802              tokenizer_next();
803            }
804          }
805  }
806}
807/*---------------------------------------------------------------------------*/
808static void
809else_statement(void)
810{
811  int r=0, endif_cntr;
812 
813  accept(TOKENIZER_ELSE);
814
815  if(if_stack_ptr > 0) {
816    r = if_stack[if_stack_ptr-1];
817  }
818 // printf("if_statement: relation %d\n", r);
819  if (tokenizer_token() == TOKENIZER_CR) { 
820          accept(TOKENIZER_CR);
821          if(!r) {
822                return;
823          }
824          else {                                     
825                endif_cntr=0;
826                tokenizer_next();       
827                while(((tokenizer_token() != TOKENIZER_ENDIF )
828                       || endif_cntr) && tokenizer_token() != TOKENIZER_ENDOFINPUT){
829                  if( tokenizer_token() == TOKENIZER_IF) {endif_cntr+=1;}                   
830                  if( tokenizer_token() == TOKENIZER_ENDIF)  {
831                    endif_cntr--;
832                  }   
833                  tokenizer_next();                                                         
834                 }
835          }                                                 
836//        accept(TOKENIZER_ENDIF);
837//        accept(TOKENIZER_CR);                       
838  }
839}
840/*---------------------------------------------------------------------------*/
841static void
842endif_statement(void)
843{
844        accept(TOKENIZER_ENDIF);
845        accept(TOKENIZER_CR);                 
846    if(if_stack_ptr > 0) {
847        if_stack_ptr--;
848    }
849}
850/*---------------------------------------------------------------------------*/
851
852/*---------------------------------------------------------------------------*/
853/* SELECT-STATEMENT                                                          */
854
855static void
856dec_select_stack(void)
857{
858  if(select_stack_ptr > 0) {
859      select_stack_ptr--;
860  } else {
861    DEBUG_PRINTF("select_statement: SELECT-Stack fail\n");
862    ended = 1;
863    ubasic_error = UBASIC_E_UNKNOWN_ERROR;  //besser neuer Fehler UBASIC_E_SELECT_STACK_EXHAUSTED,
864  }
865}
866/*---------------------------------------------------------------------------*/
867static void
868end_select_statement(void)
869{
870  if(select_stack_ptr > 0) {
871    accept(TOKENIZER_END_SELECT);
872    accept(TOKENIZER_CR);
873    dec_select_stack();
874  } else {
875    DEBUG_PRINTF("ubasic.c: end_select_statement(): end_select without select-statement\n");
876    ended = 1;
877    ubasic_error = UBASIC_E_PARSE;
878  }
879}
880/*---------------------------------------------------------------------------*/
881static void
882case_statement(void)
883{
884  int select_value, case_value_1, case_value_2, case_value_eq;
885  short case_run, case_goto = 0, case_gosub = 0;
886  int cur_ln, gosub_ln = 0;
887 
888  accept(TOKENIZER_CASE);
889  if(select_stack_ptr > 0) {
890    select_value = select_stack[select_stack_ptr - 1].select_value;
891    case_run = select_stack[select_stack_ptr - 1].case_run;
892 
893    if (!case_run) {
894      case_value_1 = expr();
895      case_value_eq = (select_value == case_value_1);
896      if (case_value_eq) { DEBUG_PRINTF("case_statement: case_value_eq %d, case_value %d\n", case_value_eq, case_value_1); } 
897
898      if(tokenizer_token() == TOKENIZER_TO) {
899        accept(TOKENIZER_TO);
900        case_value_2 = expr();
901        if (case_value_1 < case_value_2) {
902          case_value_eq = ((select_value >= case_value_1) && (select_value <= case_value_2));
903          DEBUG_PRINTF("case_statement: case_value %d to %d\n", case_value_1, case_value_2);
904        } else {
905          case_value_eq = ((select_value >= case_value_2) && (select_value <= case_value_1));
906          DEBUG_PRINTF("case_statement: case_value %d to %d\n", case_value_2, case_value_1);
907        }
908      } else if (tokenizer_token() == TOKENIZER_COMMA) {
909        do {
910          accept(TOKENIZER_COMMA);
911          if (case_value_eq) {
912            case_value_2 = expr();
913          } else {
914            case_value_1 = expr();
915            case_value_eq = (select_value == case_value_1);
916          }
917        } while (tokenizer_token() == TOKENIZER_COMMA);
918        DEBUG_PRINTF("case_statement: case_value_eq %d, case_value_comma %d\n", case_value_eq, case_value_1);
919      }
920     
921      accept(TOKENIZER_SEMICOLON);
922      if (case_value_eq) {
923        case_goto = (tokenizer_token() == TOKENIZER_GOTO);
924        case_gosub = (tokenizer_token() == TOKENIZER_GOSUB);
925//GOSUB - save curr linenumber
926        cur_ln = tokenizer_line_number();
927//GOSUB
928        statement();
929//GOSUB  - save new linenumber, reset to curr linenumber
930      if (case_gosub) {
931        gosub_ln = tokenizer_line_number();
932        jump_line(cur_ln+1);
933        DEBUG_PRINTF("case_statement: GOSUB: toLN=%d, nextLN=%d\n", gosub_ln, cur_ln+1);
934      }
935//GOSUB
936        DEBUG_PRINTF("case_statement: case execute\n");
937        case_run = 1;
938        select_stack[select_stack_ptr - 1].case_run = case_run;
939      } else {
940        DEBUG_PRINTF("case_statement: case jump; case_run: %d\n", case_run);
941        accept_cr();
942      }
943    } else {accept_cr();}
944//REM
945    while ((tokenizer_token() == TOKENIZER_REM) && (!case_goto)) {statement();}
946//REM
947    if (case_goto) { dec_select_stack(); } else {
948      if ((tokenizer_token() != TOKENIZER_CASE) && (tokenizer_token() != TOKENIZER_CASE_ELSE) &&
949         (tokenizer_token() != TOKENIZER_END_SELECT)) {
950         DEBUG_PRINTF("ubasic.c: select_statement(): don't found case, case_else or end_select\n");
951         ended = 1;
952         ubasic_error = UBASIC_E_PARSE;
953      } else {
954//GOSUB test for end_select and set to gosub-linenumber
955        if (tokenizer_token() == TOKENIZER_END_SELECT) { end_select_statement(); }
956        if (case_gosub) {
957          gosub_stack[gosub_stack_ptr-1] = tokenizer_line_number();
958          jump_line(gosub_ln);
959          DEBUG_PRINTF("end_select_statement: GOSUB: returnLN=%d\n", gosub_stack[gosub_stack_ptr-1]);
960        }
961      } 
962//GOSUB       
963    }
964  } else {
965    DEBUG_PRINTF("case_statement: SELECT-Stack fail\n");
966    ended = 1;
967    ubasic_error = UBASIC_E_UNKNOWN_ERROR;  //besser neuer Fehler UBASIC_E_SELECT_STACK_EXHAUSTED,
968  }
969}
970/*---------------------------------------------------------------------------*/
971static void
972case_else_statement(void)
973{
974  short case_goto = 0, case_gosub = 0;
975  int cur_ln, gosub_ln = 0;
976 
977  accept(TOKENIZER_CASE_ELSE);
978  if(select_stack_ptr > 0) {
979    if (!select_stack[select_stack_ptr - 1].case_run) {
980      case_goto = (tokenizer_token() == TOKENIZER_GOTO);
981      case_gosub = (tokenizer_token() == TOKENIZER_GOSUB);
982//GOSUB - save curr linenumber
983      cur_ln = tokenizer_line_number();
984//GOSUB
985      statement();
986//GOSUB  - save new linenumber, reset to curr linenumber
987      if (case_gosub) {
988        gosub_ln = tokenizer_line_number();
989        jump_line(cur_ln+1);
990        DEBUG_PRINTF("case_else_statement: GOSUB: toLN=%d, nextLN=%d\n", gosub_ln, cur_ln+1);
991      }
992//GOSUB
993      DEBUG_PRINTF("case_else_statement: case_else execute\n");
994    } else {
995      DEBUG_PRINTF("case_else_statement: case_else jump; case_run: %d\n", select_stack[select_stack_ptr - 1].case_run);
996      accept_cr();
997    }
998//REM
999    while ((tokenizer_token() == TOKENIZER_REM) && (!case_goto)) {statement();}
1000//REM
1001    if (case_goto) { dec_select_stack(); } else {
1002//GOSUB test for end_select and set to gosub-linenumber
1003      if (tokenizer_token() != TOKENIZER_END_SELECT) {
1004        DEBUG_PRINTF("ubasic.c: select_statement(): don't found end_select\n");
1005        ended = 1;
1006        ubasic_error = UBASIC_E_PARSE;
1007      } else {
1008          end_select_statement();
1009        if (case_gosub) {
1010          gosub_stack[gosub_stack_ptr-1] = tokenizer_line_number();
1011          jump_line(gosub_ln);
1012          DEBUG_PRINTF("end_select_statement: GOSUB: returnLN=%d\n", gosub_stack[gosub_stack_ptr-1]);
1013        }
1014      } 
1015//GOSUB     
1016    }
1017  } else {
1018    DEBUG_PRINTF("case_else_statement: SELECT-Stack fault\n");
1019    ended = 1;
1020    ubasic_error = UBASIC_E_UNKNOWN_ERROR;  //besser neuer Fehler UBASIC_E_SELECT_STACK_EXHAUSTED,
1021  }
1022}
1023/*---------------------------------------------------------------------------*/
1024static void
1025select_statement(void)
1026{
1027 
1028  int select_value;
1029 
1030  accept(TOKENIZER_SELECT);
1031  select_value = expr(); 
1032  accept(TOKENIZER_CR);
1033//REM
1034    while (tokenizer_token() == TOKENIZER_REM) {statement();}
1035//REM
1036 
1037  if(select_stack_ptr < MAX_SELECT_STACK_DEPTH) {
1038    select_stack[select_stack_ptr].select_value = select_value;
1039    select_stack[select_stack_ptr].case_run = 0;
1040    DEBUG_PRINTF("select_statement: new select, value %d\n",select_stack[select_stack_ptr].select_value);
1041    select_stack_ptr++;
1042    if (tokenizer_token() != TOKENIZER_CASE) {
1043      DEBUG_PRINTF("ubasic.c: select_statement(): don't found case-statement\n");
1044      ended = 1;
1045      ubasic_error = UBASIC_E_PARSE;
1046    }
1047    else { case_statement(); }
1048  } else {
1049    DEBUG_PRINTF("select_statement: SELECT-stack depth exceeded\n");
1050    ended = 1;
1051    ubasic_error = UBASIC_E_UNKNOWN_ERROR;  //besser neuer Fehler UBASIC_E_SELECT_STACK_EXHAUSTED,
1052  }
1053}
1054/* SELECT-STATEMENT END                                                      */
1055/*---------------------------------------------------------------------------*/
1056static void
1057let_statement(void)
1058{
1059 
1060  int var;
1061
1062  var = tokenizer_variable_num();
1063
1064  accept(TOKENIZER_VARIABLE);
1065  accept(TOKENIZER_EQ);
1066  ubasic_set_variable(var, expr());
1067  DEBUG_PRINTF("let_statement: assign %d to %d\n", variables[var], var);
1068  accept_cr();
1069}
1070/*---------------------------------------------------------------------------*/
1071static void
1072rem_statement(void)
1073{
1074  accept(TOKENIZER_REM);
1075  DEBUG_PRINTF("rem_statement\n");
1076  accept(TOKENIZER_CR);
1077}
1078/*---------------------------------------------------------------------------*/
1079static void
1080cls_statement(void)
1081{
1082  accept(TOKENIZER_CLS);
1083  script_console_clear();
1084  DEBUG_PRINTF("cls_statement\n");
1085  accept(TOKENIZER_CR);
1086}
1087/*---------------------------------------------------------------------------*/
1088static void
1089gosub_statement(void)
1090{
1091  accept(TOKENIZER_GOSUB);
1092  if(tokenizer_token() == TOKENIZER_STRING) {
1093    tokenizer_string(string, sizeof(string));
1094    do {
1095    tokenizer_next();
1096    } while(tokenizer_token() != TOKENIZER_CR);
1097    accept(TOKENIZER_CR);
1098    if(gosub_stack_ptr < MAX_GOSUB_STACK_DEPTH) {
1099/*    tokenizer_line_number_inc();*/
1100      gosub_stack[gosub_stack_ptr] = tokenizer_line_number();
1101      gosub_stack_ptr++;
1102      jump_label(string);
1103    } else {
1104      DEBUG_PRINTF("gosub_statement: gosub stack exhausted\n");
1105      ended = 1;
1106      ubasic_error = UBASIC_E_GOSUB_STACK_EXHAUSTED;
1107    }
1108  } else {
1109    DEBUG_PRINTF("ubasic.c: goto_statement(): no label specified\n");
1110    ended = 1;
1111    ubasic_error = UBASIC_E_UNK_LABEL;
1112  }
1113}
1114/*---------------------------------------------------------------------------*/
1115static void
1116return_statement(void)
1117{
1118  accept(TOKENIZER_RETURN);
1119  if(gosub_stack_ptr > 0) {
1120    gosub_stack_ptr--;
1121    jump_line(gosub_stack[gosub_stack_ptr]);
1122  } else {
1123    DEBUG_PRINTF("return_statement: non-matching return\n");
1124    ended = 1;
1125    ubasic_error = UBASIC_E_UNMATCHED_RETURN;
1126  }
1127}
1128/*---------------------------------------------------------------------------*/
1129static void
1130next_statement(void)
1131{
1132  int var, value;
1133 
1134  accept(TOKENIZER_NEXT);
1135  var = tokenizer_variable_num();
1136  accept(TOKENIZER_VARIABLE);
1137  if(for_stack_ptr > 0 &&
1138     var == for_stack[for_stack_ptr - 1].for_variable) {
1139    value = ubasic_get_variable(var) + for_stack[for_stack_ptr - 1].step;
1140    ubasic_set_variable(var, value);
1141   
1142    if(((for_stack[for_stack_ptr - 1].step > 0) && (value <= for_stack[for_stack_ptr - 1].to)) ||
1143       ((for_stack[for_stack_ptr - 1].step < 0) && (value >= for_stack[for_stack_ptr - 1].to)))
1144        jump_line(for_stack[for_stack_ptr - 1].line_after_for);
1145    else {
1146      for_stack_ptr--;
1147      accept(TOKENIZER_CR);
1148    }
1149  } else {
1150    DEBUG_PRINTF("next_statement: non-matching next (expected %d, found %d)\n", for_stack[for_stack_ptr - 1].for_variable, var);
1151    accept(TOKENIZER_CR);
1152  }
1153
1154}
1155/*---------------------------------------------------------------------------*/
1156static void
1157for_statement(void)
1158{
1159  int for_variable, to, step;
1160 
1161  accept(TOKENIZER_FOR);
1162  for_variable = tokenizer_variable_num();
1163  accept(TOKENIZER_VARIABLE);
1164  accept(TOKENIZER_EQ);
1165  ubasic_set_variable(for_variable, expr());
1166  accept(TOKENIZER_TO);
1167  to = expr();                     
1168  step = 1;
1169  if (tokenizer_token() != TOKENIZER_CR) {
1170          accept(TOKENIZER_STEP);
1171          step = expr();         
1172  }
1173  accept(TOKENIZER_CR);
1174
1175  if(for_stack_ptr < MAX_FOR_STACK_DEPTH) {
1176    for_stack[for_stack_ptr].line_after_for = tokenizer_line_number();
1177    for_stack[for_stack_ptr].for_variable = for_variable;
1178    for_stack[for_stack_ptr].to = to;
1179    for_stack[for_stack_ptr].step = step;
1180    DEBUG_PRINTF("for_statement: new for, var %d to %d\n",
1181                 for_stack[for_stack_ptr].for_variable,
1182                 for_stack[for_stack_ptr].to);
1183                 
1184    for_stack_ptr++;
1185  } else {
1186    DEBUG_PRINTF("for_statement: for stack depth exceeded\n");
1187  }
1188}
1189/*---------------------------------------------------------------------------*/
1190static void
1191do_statement(void)
1192{
1193  accept(TOKENIZER_DO);
1194  accept(TOKENIZER_CR);
1195  if(do_stack_ptr < MAX_DO_STACK_DEPTH) {
1196     do_stack[do_stack_ptr] = tokenizer_line_number();
1197     do_stack_ptr++;
1198  }
1199}
1200/*---------------------------------------------------------------------------*/
1201static void
1202until_statement(void)
1203{
1204  int r;
1205 
1206  accept(TOKENIZER_UNTIL);
1207  r = relation();
1208  if(!r) {
1209    if(do_stack_ptr > 0) {
1210      jump_line(do_stack[do_stack_ptr-1]);
1211    }
1212  }
1213  else {
1214    do_stack_ptr--;
1215        accept_cr();
1216  }
1217
1218}
1219/*---------------------------------------------------------------------------*/
1220static void
1221while_statement(void)
1222{
1223  int r, while_cntr;
1224 
1225  accept(TOKENIZER_WHILE);
1226  if(while_stack_ptr < MAX_WHILE_STACK_DEPTH) {
1227    if ((while_stack_ptr == 0)||((while_stack_ptr > 0) && (while_stack[while_stack_ptr-1] != tokenizer_line_number()))){
1228      while_stack[while_stack_ptr] = tokenizer_line_number();
1229      while_stack_ptr++;
1230    }
1231  }
1232  r = relation();
1233  if(!r) {
1234        while_cntr=0;
1235    while((tokenizer_token() != TOKENIZER_WEND  || while_cntr ) &&
1236            tokenizer_token() != TOKENIZER_ENDOFINPUT){   
1237            if (tokenizer_token() == TOKENIZER_WHILE) while_cntr+=1;
1238            if (tokenizer_token() == TOKENIZER_WEND) while_cntr-=1;           
1239          tokenizer_next();
1240        } 
1241    while_stack_ptr--;
1242   
1243    accept(TOKENIZER_WEND);
1244    accept(TOKENIZER_CR);       
1245  }
1246  else  {
1247        accept_cr();       
1248  }
1249}
1250/*---------------------------------------------------------------------------*/
1251static void
1252wend_statement(void)
1253{
1254  accept(TOKENIZER_WEND);
1255  if(while_stack_ptr > 0) {
1256    jump_line(while_stack[while_stack_ptr-1]);
1257  }
1258  else {
1259        accept_cr();
1260  }
1261}
1262/*---------------------------------------------------------------------------*/
1263static void
1264end_statement(void)
1265{
1266  accept(TOKENIZER_END);
1267  ended = 1;
1268}
1269/*---------------------------------------------------------------------------*/
1270static void
1271click_statement(void)
1272{
1273  accept(TOKENIZER_CLICK);
1274  tokenizer_string(string, sizeof(string));
1275  ubasic_camera_click(string);
1276  tokenizer_next();
1277  DEBUG_PRINTF("End of click\n");
1278  accept_cr();
1279}
1280/*---------------------------------------------------------------------------*/
1281static void
1282press_statement(void)
1283{
1284  accept(TOKENIZER_PRESS);
1285  tokenizer_string(string, sizeof(string));
1286  ubasic_camera_press(string);
1287  tokenizer_next();
1288  DEBUG_PRINTF("End of press\n");
1289  accept_cr();
1290}
1291/*---------------------------------------------------------------------------*/
1292static void
1293release_statement(void)
1294{
1295  accept(TOKENIZER_RELEASE);
1296  tokenizer_string(string, sizeof(string));
1297  ubasic_camera_release(string);
1298  tokenizer_next();
1299  DEBUG_PRINTF("End of release\n");
1300  accept_cr();
1301}
1302/*---------------------------------------------------------------------------*/
1303static void
1304sleep_statement(void)
1305{
1306  int val;
1307  accept(TOKENIZER_SLEEP);
1308  val = expr();
1309  ubasic_camera_sleep(val);
1310  DEBUG_PRINTF("End of sleep\n");
1311  accept_cr();
1312}
1313/*---------------------------------------------------------------------------*/
1314static void
1315shoot_statement(void)
1316{
1317  accept(TOKENIZER_SHOOT);
1318  ubasic_camera_shoot();
1319  DEBUG_PRINTF("End of shoot\n");
1320  accept_cr();
1321}
1322
1323/*---------------------------------------------------------------------------*/
1324
1325#ifdef INCLUDE_OLD_GET__SYNTAX
1326
1327static void get_tv96_statement()
1328{
1329    int var;
1330    accept(TOKENIZER_GET_TV96);
1331    var = tokenizer_variable_num();
1332    accept(TOKENIZER_VARIABLE);
1333    ubasic_set_variable(var, shooting_get_tv96());
1334    accept_cr();
1335}
1336
1337static void get_user_tv96_statement()
1338{
1339    int var;
1340    accept(TOKENIZER_GET_USER_TV96);
1341    var = tokenizer_variable_num();
1342    accept(TOKENIZER_VARIABLE);
1343    ubasic_set_variable(var, shooting_get_user_tv96());
1344    accept_cr();
1345}
1346
1347
1348static void get_user_tv_id_statement()
1349{
1350    int var;
1351    accept(TOKENIZER_GET_USER_TV_ID);
1352    var = tokenizer_variable_num();
1353    accept(TOKENIZER_VARIABLE);
1354    ubasic_set_variable(var, shooting_get_user_tv_id());
1355    accept_cr();
1356}
1357
1358static void get_av96_statement()
1359{
1360    int var;
1361    accept(TOKENIZER_GET_AV96);
1362    var = tokenizer_variable_num();
1363    accept(TOKENIZER_VARIABLE);
1364    ubasic_set_variable(var, shooting_get_av96());
1365    accept_cr();
1366}
1367
1368static void get_user_av96_statement()
1369{
1370    int var;
1371    accept(TOKENIZER_GET_USER_AV96);
1372    var = tokenizer_variable_num();
1373    accept(TOKENIZER_VARIABLE);
1374    ubasic_set_variable(var, shooting_get_user_av96());
1375    accept_cr();
1376}
1377
1378static void get_user_av_id_statement()
1379{
1380    int var;
1381    accept(TOKENIZER_GET_USER_AV_ID);
1382    var = tokenizer_variable_num();
1383    accept(TOKENIZER_VARIABLE);
1384    ubasic_set_variable(var, shooting_get_user_av_id());
1385    accept_cr();
1386}
1387
1388static void get_zoom_statement()
1389{
1390    int var;
1391    accept(TOKENIZER_GET_ZOOM);
1392    var = tokenizer_variable_num();
1393    accept(TOKENIZER_VARIABLE);
1394    ubasic_set_variable(var, shooting_get_zoom());
1395    accept_cr();
1396}
1397
1398static void get_focus_statement()
1399{
1400    int var;
1401    accept(TOKENIZER_GET_FOCUS);
1402    var = tokenizer_variable_num();
1403    accept(TOKENIZER_VARIABLE);
1404    ubasic_set_variable(var, shooting_get_subject_distance());
1405    accept_cr();
1406}
1407
1408static void get_near_limit_statement()
1409{
1410    int var;
1411    accept(TOKENIZER_GET_NEAR_LIMIT);
1412    var = tokenizer_variable_num();
1413    accept(TOKENIZER_VARIABLE);
1414    ubasic_set_variable(var, shooting_get_near_limit_of_acceptable_sharpness());
1415    accept_cr();
1416}
1417
1418static void get_far_limit_statement()
1419{
1420    int var;
1421    accept(TOKENIZER_GET_FAR_LIMIT);
1422    var = tokenizer_variable_num();
1423    accept(TOKENIZER_VARIABLE);
1424    ubasic_set_variable(var, shooting_get_far_limit_of_acceptable_sharpness());
1425    accept_cr();
1426}
1427
1428static void get_dof_statement()
1429{
1430    int var;
1431    accept(TOKENIZER_GET_DOF);
1432    var = tokenizer_variable_num();
1433    accept(TOKENIZER_VARIABLE);
1434    ubasic_set_variable(var, shooting_get_depth_of_field());
1435    accept_cr();
1436}
1437
1438static void get_hyperfocal_distance_statement()
1439{
1440    int var;
1441    accept(TOKENIZER_GET_HYPERFOCAL_DIST);
1442    var = tokenizer_variable_num();
1443    accept(TOKENIZER_VARIABLE);
1444    ubasic_set_variable(var, shooting_get_hyperfocal_distance());
1445    accept_cr();
1446}
1447
1448static void get_disk_size_statement()
1449{
1450    int var;
1451    accept(TOKENIZER_GET_DISK_SIZE);
1452    var = tokenizer_variable_num();
1453    accept(TOKENIZER_VARIABLE);
1454    ubasic_set_variable(var, GetTotalCardSpaceKb());
1455    accept_cr();
1456}
1457
1458static void get_free_disk_space_statement()
1459{
1460    int var;
1461    accept(TOKENIZER_GET_FREE_DISK_SPACE);
1462    var = tokenizer_variable_num();
1463    accept(TOKENIZER_VARIABLE);
1464    ubasic_set_variable(var, GetFreeCardSpaceKb());
1465    accept_cr();
1466}
1467
1468static void get_jpg_count_statement()
1469{
1470    int var;
1471    accept(TOKENIZER_GET_JPG_COUNT);
1472    var = tokenizer_variable_num();
1473    accept(TOKENIZER_VARIABLE);
1474    ubasic_set_variable(var, GetJpgCount());
1475    accept_cr();
1476}
1477
1478static void get_raw_count_statement()
1479{
1480    int var;
1481    accept(TOKENIZER_GET_RAW_COUNT);
1482    var = tokenizer_variable_num();
1483    accept(TOKENIZER_VARIABLE);
1484    ubasic_set_variable(var, GetRawCount());
1485    accept_cr();
1486}
1487
1488static void get_vbatt_statement()
1489{
1490    int var;
1491    accept(TOKENIZER_GET_VBATT);
1492    var = tokenizer_variable_num();
1493    accept(TOKENIZER_VARIABLE);
1494    ubasic_set_variable(var, (unsigned short)stat_get_vbatt());
1495       
1496    accept_cr();
1497}
1498
1499static void get_prop_statement()
1500{
1501    int var, var1;
1502    accept(TOKENIZER_GET_PROP);
1503    var = expr();
1504    var1 = tokenizer_variable_num();
1505    accept(TOKENIZER_VARIABLE);
1506    ubasic_set_variable(var1, shooting_get_prop(var));
1507       
1508    accept_cr();
1509}
1510
1511static void get_iso_market_statement()
1512{
1513    int var;
1514    accept(TOKENIZER_GET_ISO_MARKET);
1515    var = tokenizer_variable_num();
1516    accept(TOKENIZER_VARIABLE);
1517    ubasic_set_variable(var, (int)shooting_get_iso_market());
1518    accept_cr();
1519}
1520
1521static void get_iso_real_statement()
1522{
1523    int var;
1524    accept(TOKENIZER_GET_ISO_REAL);
1525    var = tokenizer_variable_num();
1526    accept(TOKENIZER_VARIABLE);
1527    ubasic_set_variable(var, (int)shooting_get_iso_real());
1528    accept_cr();
1529}
1530
1531static void get_bv96_statement()
1532{
1533    int var;
1534    accept(TOKENIZER_GET_BV96);
1535    var = tokenizer_variable_num();
1536    accept(TOKENIZER_VARIABLE);
1537    ubasic_set_variable(var, (int)shooting_get_bv96());
1538    accept_cr();
1539}
1540
1541static void get_sv96_statement()
1542{
1543    int var;
1544    accept(TOKENIZER_GET_SV96);
1545    var = tokenizer_variable_num();
1546    accept(TOKENIZER_VARIABLE);
1547    ubasic_set_variable(var, (int)shooting_get_sv96());
1548    accept_cr();
1549}
1550
1551static void get_iso_mode_statement()
1552{
1553    int var;
1554    accept(TOKENIZER_GET_ISO_MODE);
1555    var = tokenizer_variable_num();
1556    accept(TOKENIZER_VARIABLE);
1557    ubasic_set_variable(var, shooting_get_iso_mode());
1558    accept_cr();
1559}
1560
1561#endif
1562
1563
1564static void set_tv96_statement()
1565{
1566    int to;
1567    accept(TOKENIZER_SET_TV96);
1568    to = expr();
1569    shooting_set_tv96((short int)to, SET_LATER);
1570    accept_cr();
1571}
1572
1573static void play_sound_statement()
1574{
1575    int to;
1576    accept(TOKENIZER_PLAY_SOUND);
1577    to = expr();
1578    play_sound(to);
1579    accept_cr();
1580}
1581static void set_shutter_speed_statement()
1582{
1583    int to;
1584    accept(TOKENIZER_SET_SHUTTER_SPEED);
1585    to = expr();
1586    shooting_set_shutter_speed_ubasic(to, SET_LATER);
1587    accept_cr();
1588}
1589
1590static void set_tv96_direct_statement()
1591{
1592    int to;
1593    accept(TOKENIZER_SET_TV96_DIRECT);
1594    to = expr();
1595    shooting_set_tv96_direct((short int)to, SET_LATER);
1596    accept_cr();
1597}
1598
1599static void set_user_tv96_statement()
1600{
1601    int to;
1602    accept(TOKENIZER_SET_USER_TV96);
1603    to = expr();
1604    shooting_set_user_tv96((short int)to);
1605    accept_cr();
1606}
1607
1608static void set_user_tv_by_id_statement()
1609{
1610    int to;
1611    accept(TOKENIZER_SET_USER_TV_BY_ID);
1612    to = expr();
1613    shooting_set_user_tv_by_id(to);
1614    accept_cr();
1615}
1616
1617static void set_user_tv_by_id_rel_statement()
1618{
1619    int to;
1620    accept(TOKENIZER_SET_USER_TV_BY_ID_REL);
1621    to = expr();
1622    shooting_set_user_tv_by_id_rel(to);
1623    accept_cr();
1624}
1625
1626static void set_sv96_statement()
1627{
1628    int to;
1629    accept(TOKENIZER_SET_SV96);
1630    to = expr();
1631    shooting_set_sv96((short int)to, SET_LATER);
1632    accept_cr();
1633}
1634
1635
1636/*---------------------------------------------------------------------------*/
1637
1638
1639static void set_av96_statement()
1640{
1641    int to;
1642    accept(TOKENIZER_SET_AV96);
1643    to = expr();
1644    shooting_set_av96((short int)to, SET_LATER);
1645    accept_cr();
1646}
1647
1648static void set_av96_direct_statement()
1649{
1650    int to;
1651    accept(TOKENIZER_SET_AV96_DIRECT);
1652    to = expr();
1653    shooting_set_av96_direct((short int)to, SET_LATER);
1654    accept_cr();
1655}
1656
1657static void set_user_av96_statement()
1658{
1659    int to;
1660    accept(TOKENIZER_SET_USER_AV96);
1661    to = expr();
1662    shooting_set_user_av96((short int)to);
1663    accept_cr();
1664}
1665
1666static void set_user_av_by_id_statement()
1667{
1668    int to;
1669    accept(TOKENIZER_SET_USER_AV_BY_ID);
1670    to = expr();
1671    shooting_set_user_av_by_id(to);
1672    accept_cr();
1673}
1674
1675static void set_user_av_by_id_rel_statement()
1676{
1677    int to;
1678    accept(TOKENIZER_SET_USER_AV_BY_ID_REL);
1679    to = expr();
1680    shooting_set_user_av_by_id_rel(to);
1681    accept_cr();
1682}
1683
1684/*---------------------------------------------------------------------------*/
1685
1686static void set_zoom_statement()
1687{
1688    int to;
1689    accept(TOKENIZER_SET_ZOOM);
1690    to = expr();
1691    shooting_set_zoom(to);
1692    accept_cr();
1693}
1694
1695static void set_zoom_rel_statement()
1696{
1697    int to;
1698    accept(TOKENIZER_SET_ZOOM_REL);
1699    to = expr();
1700    shooting_set_zoom_rel(to);
1701    accept_cr();
1702}
1703
1704static void set_zoom_speed_statement()
1705{
1706    int to;
1707    accept(TOKENIZER_SET_ZOOM_SPEED);
1708    to = expr();
1709    shooting_set_zoom_speed(to);
1710    accept_cr();
1711}
1712
1713/*---------------------------------------------------------------------------*/
1714
1715
1716static void set_ev_statement()
1717        {
1718            int to;
1719            accept(TOKENIZER_SET_EV);
1720            to = expr();
1721                shooting_set_prop(PROPCASE_EV_CORRECTION_1, to);
1722                shooting_set_prop(PROPCASE_EV_CORRECTION_2, to);
1723            accept_cr();
1724        }
1725
1726static void set_movie_status_statement()
1727{
1728    int to;
1729    accept(TOKENIZER_SET_MOVIE_STATUS);
1730    to = expr();
1731if (to==1) {
1732        if (movie_status == 4) {
1733        movie_status = 1;
1734}}
1735if (to==2) {
1736        if (movie_status == 1) {
1737        movie_status = 4;
1738}
1739}
1740if (to==3) {
1741        if (movie_status == 1 || 4) {
1742        movie_status = 5;
1743}}
1744
1745
1746    accept_cr();
1747}
1748
1749static void set_resolution_statement()
1750{
1751    int to;
1752    accept(TOKENIZER_SET_RESOLUTION);
1753    to = expr();
1754                shooting_set_prop(PROPCASE_RESOLUTION, to);
1755    accept_cr();
1756}
1757
1758static void set_quality_statement()
1759{
1760    int to;
1761    accept(TOKENIZER_SET_QUALITY);
1762    to = expr();
1763                shooting_set_prop(PROPCASE_QUALITY, to);
1764    accept_cr();
1765}
1766
1767
1768static void set_focus_statement()
1769{
1770    int to;
1771    accept(TOKENIZER_SET_FOCUS);
1772    to = expr();
1773    int m=mode_get()&MODE_SHOOTING_MASK;
1774        int mode_video=MODE_IS_VIDEO(m);
1775#if CAM_HAS_MANUAL_FOCUS
1776    if (shooting_get_focus_mode() || (mode_video)) shooting_set_focus(to, SET_NOW);
1777    else shooting_set_focus(to, SET_LATER);
1778#else
1779    if (mode_video) shooting_set_focus(to, SET_NOW);
1780    else shooting_set_focus(to, SET_LATER);   
1781#endif   
1782    accept_cr();
1783}
1784
1785static void set_led_statement()
1786{
1787    int to, to1, to2;
1788    accept(TOKENIZER_SET_LED);
1789    to = expr();
1790    to1 = expr();
1791        to2 = 200;
1792        if (tokenizer_token() != TOKENIZER_CR && tokenizer_token() != TOKENIZER_ELSE ) {
1793                to2 = expr();
1794    }
1795        ubasic_set_led(to, to1, to2);
1796    accept_cr();
1797}
1798static void set_prop_statement()
1799{
1800    int to, to1;
1801    accept(TOKENIZER_SET_PROP);
1802    to = expr();
1803    to1 = expr();
1804        shooting_set_prop(to, to1);
1805    accept_cr();
1806}
1807
1808
1809
1810/*---------------------------------------------------------------------------*/
1811//ARM Begin
1812
1813
1814/*static void set_iso_market_statement()
1815{
1816    int to;
1817    accept(TOKENIZER_SET_ISO_MARKET);
1818    to = expr();
1819    shooting_set_iso_market(to);
1820    accept_cr();
1821}
1822
1823static void set_iso_real_delta_from_base_statement()
1824{
1825    int to;
1826    accept(TOKENIZER_SET_ISO_DL_F_B);
1827    to = expr();
1828    shooting_set_iso_real_delta_from_base(to);
1829    accept_cr();
1830}*/
1831
1832static void set_iso_real_statement()
1833{
1834    short int to;
1835    accept(TOKENIZER_SET_ISO_REAL);
1836    to = expr();
1837    shooting_set_iso_real(to, SET_LATER);
1838    accept_cr();
1839}
1840
1841//ARM End
1842
1843
1844static void set_iso_mode_statement()
1845{
1846    int to;
1847    accept(TOKENIZER_SET_ISO_MODE);
1848    to = expr();
1849    shooting_set_iso_mode(to);
1850    accept_cr();
1851}
1852static void set_raw_statement()
1853{
1854    int to;
1855    accept(TOKENIZER_SET_RAW);
1856    to = expr();
1857    ubasic_camera_set_raw(to);
1858    accept_cr();
1859}
1860static void set_raw_nr_statement()
1861{
1862    int to;
1863    accept(TOKENIZER_SET_RAW_NR);
1864    to = expr();
1865    ubasic_camera_set_nr(to);
1866    accept_cr();
1867}
1868
1869static void set_nd_filter_statement()
1870{
1871    int to;
1872    accept(TOKENIZER_SET_ND_FILTER);
1873    to = expr();
1874    shooting_set_nd_filter_state(to, SET_LATER);
1875    accept_cr();
1876}
1877
1878
1879static void set_autostart_statement()
1880{
1881    int to;
1882    accept(TOKENIZER_SET_SCRIPT_AUTOSTART);
1883    to = expr();
1884#ifndef UBASIC_TEST
1885        if (to >= 0 && to <= 2) conf.script_startup=to;
1886        conf_save();
1887#endif
1888    accept_cr();
1889}
1890static void exit_alt_statement()
1891{
1892    int to;
1893    accept(TOKENIZER_EXIT_ALT);
1894    to = expr();
1895    exit_alt(to);
1896    accept_cr();
1897}
1898/*---------------------------------------------------------------------------*/
1899
1900static void wait_click_statement()
1901{
1902    int timeout=0;
1903    accept(TOKENIZER_WAIT_CLICK);
1904    if (tokenizer_token() != TOKENIZER_CR &&
1905        tokenizer_token() != TOKENIZER_ELSE ) {
1906        timeout = expr();
1907    }
1908    ubasic_camera_wait_click(timeout);
1909    accept_cr();
1910}
1911
1912static void is_key_statement(void)
1913{
1914    int var;
1915    accept(TOKENIZER_IS_KEY);
1916    var = tokenizer_variable_num();
1917    accept(TOKENIZER_VARIABLE);
1918    tokenizer_string(string, sizeof(string));
1919    tokenizer_next();
1920    ubasic_set_variable(var, ubasic_camera_is_clicked(string));
1921    DEBUG_PRINTF("End of is_key\n");
1922    accept_cr();
1923}
1924
1925static void wheel_left_statement(void){
1926  accept(TOKENIZER_WHEEL_LEFT);
1927#ifdef CAM_HAS_JOGDIAL
1928  JogDial_CCW();
1929#endif
1930  accept_cr();
1931}
1932
1933
1934static void wheel_right_statement(void){
1935  accept(TOKENIZER_WHEEL_RIGHT);
1936#ifdef CAM_HAS_JOGDIAL
1937  JogDial_CW();
1938#endif
1939  accept_cr();
1940}
1941
1942static void set_backlight_statement(void)
1943{
1944  int val;
1945  accept(TOKENIZER_SET_BACKLIGHT);
1946  val = expr();
1947  if (val > 0) TurnOnBackLight();
1948  else TurnOffBackLight();
1949  accept_cr();
1950}
1951
1952static void
1953set_aflock_statement(void)
1954{
1955  int val;
1956  accept(TOKENIZER_SET_AFLOCK);
1957  val = expr();
1958  if (val>0) DoAFLock();  // 1: enable AFLock
1959  else UnlockAF();       // 0: disable unlock AF
1960  accept_cr();
1961}
1962
1963
1964static void shutdown_statement(void){
1965  accept(TOKENIZER_SHUT_DOWN);
1966  camera_shutdown_in_a_second();
1967  accept_cr();
1968}
1969
1970/*---------------------------------------------------------------------------*/
1971
1972static void md_get_cell_diff_statement()
1973{
1974    int var, col, row;
1975    accept(TOKENIZER_MD_GET_CELL_DIFF);
1976
1977                col=expr();tokenizer_next();
1978
1979                row=expr();tokenizer_next();
1980
1981    var = tokenizer_variable_num();
1982    accept(TOKENIZER_VARIABLE);
1983       
1984    ubasic_set_variable(var, md_get_cell_diff(col,row));
1985    accept_cr();
1986}
1987
1988static void md_detect_motion_statement()
1989{
1990
1991 int columns;
1992 int rows;
1993 int pixel_measure_mode;
1994 int detection_timeout;
1995 int measure_interval;
1996 int threshold;
1997 int draw_grid=0;
1998 int clipping_region_mode=0;
1999 int clipping_region_row1=0;
2000 int clipping_region_column1=0;
2001 int clipping_region_row2=0;
2002 int clipping_region_column2=0;
2003 int ret_var_num;
2004 int parameters=0;
2005 int pixels_step=1;
2006 int msecs_before_trigger=0;
2007
2008 //static char buf[128];
2009
2010    accept(TOKENIZER_MD_DETECT_MOTION);
2011
2012//              sprintf(buf,"token: %d",tokenizer_token()); script_console_add_line(buf);
2013                columns=expr();tokenizer_next();
2014
2015//              sprintf(buf,"tk: %d",tokenizer_token()); script_console_add_line(buf);
2016                rows=expr();tokenizer_next();
2017
2018//              sprintf(buf,"tk %d",tokenizer_token()); script_console_add_line(buf);
2019                pixel_measure_mode=expr();tokenizer_next();
2020
2021                detection_timeout=expr();tokenizer_next();
2022
2023//              printf("token: %d",tokenizer_token());
2024                measure_interval=expr();tokenizer_next();
2025
2026//              printf("token: %d",tokenizer_token());
2027                threshold=expr();tokenizer_next();
2028
2029//              printf("token: %d",tokenizer_token());
2030                draw_grid=expr();tokenizer_next();
2031
2032//              printf("token: %d",tokenizer_token());
2033    ret_var_num = tokenizer_variable_num();
2034
2035//              printf("%d,%d,%d,%d",columns,rows,pixel_measure_mode, detection_timeout);
2036
2037    accept(TOKENIZER_VARIABLE);
2038
2039
2040    if (tokenizer_token() != TOKENIZER_CR && tokenizer_token() != TOKENIZER_ELSE) {
2041                        // eat COMA     
2042//                      tokenizer_next();
2043                }
2044
2045
2046               
2047    if (tokenizer_token() != TOKENIZER_CR && tokenizer_token() != TOKENIZER_ELSE) {
2048                                tokenizer_next();
2049        clipping_region_mode = expr();
2050    }
2051    if (tokenizer_token() != TOKENIZER_CR && tokenizer_token() != TOKENIZER_ELSE ) {
2052                                tokenizer_next();
2053        clipping_region_column1 = expr();
2054    }
2055    if (tokenizer_token() != TOKENIZER_CR && tokenizer_token() != TOKENIZER_ELSE ) {
2056                                tokenizer_next();
2057        clipping_region_row1 = expr();
2058    }
2059    if (tokenizer_token() != TOKENIZER_CR && tokenizer_token() != TOKENIZER_ELSE ) {
2060                                tokenizer_next();
2061        clipping_region_column2 = expr();
2062    }
2063    if (tokenizer_token() != TOKENIZER_CR && tokenizer_token() != TOKENIZER_ELSE ) {
2064                                tokenizer_next();
2065        clipping_region_row2 = expr();
2066    }
2067    if (tokenizer_token() != TOKENIZER_CR && tokenizer_token() != TOKENIZER_ELSE ) {
2068                                tokenizer_next();
2069        parameters = expr();
2070    }
2071    if (tokenizer_token() != TOKENIZER_CR && tokenizer_token() != TOKENIZER_ELSE ) {
2072                                tokenizer_next();
2073        pixels_step = expr();
2074    }
2075
2076    if (tokenizer_token() != TOKENIZER_CR && tokenizer_token() != TOKENIZER_ELSE ) {
2077                                tokenizer_next();
2078        msecs_before_trigger = expr();
2079    }
2080                       
2081
2082    accept_cr();
2083
2084//              sprintf(buf,"[%dx%d] md:%d tmout:%d", columns, rows, pixel_measure_mode, detection_timeout);
2085//              script_console_add_line(buf);
2086
2087//              sprintf(buf,"int:%d trsh:%d g:%d vr:%d", measure_interval, threshold, draw_grid, ret_var_num);
2088//              script_console_add_line(buf);
2089
2090//              sprintf(buf,"clip %d [%d,%d][%d,%d]", clipping_region_mode, clipping_region_column1, clipping_region_row1, clipping_region_column2,clipping_region_row2);
2091//              script_console_add_line(buf);
2092
2093        md_init_motion_detector(
2094                        columns, rows, pixel_measure_mode, detection_timeout,
2095                        measure_interval, threshold, draw_grid, ret_var_num,
2096                        clipping_region_mode,
2097                        clipping_region_column1, clipping_region_row1,
2098                        clipping_region_column2, clipping_region_row2,
2099                        parameters, pixels_step, msecs_before_trigger
2100        );
2101}
2102
2103/*---------------------------------------------------------------------------*/
2104
2105static void shot_histo_enable_statement()
2106{
2107    int to;
2108    accept(TOKENIZER_SHOT_HISTO_ENABLE);
2109    to = expr();
2110    shot_histogram_set(to);
2111    accept_cr();
2112}
2113
2114static void set_record_statement()
2115{
2116    int to;
2117    accept(TOKENIZER_SET_RECORD);
2118    to = expr();
2119    if(to) {
2120        levent_set_record();
2121    }
2122    else {
2123        levent_set_play();
2124    }
2125    accept_cr();
2126}
2127
2128
2129static void
2130statement(void)
2131{
2132  ubasic_token token;
2133
2134  token = tokenizer_token();
2135
2136  switch(token) {
2137// aflock
2138  case TOKENIZER_SET_AFLOCK:
2139    set_aflock_statement();
2140    break;
2141
2142  case TOKENIZER_PRINT_SCREEN:
2143    print_screen_statement();
2144    break;
2145  case TOKENIZER_PRINT:
2146    print_statement();
2147    break;
2148
2149  case TOKENIZER_SLEEP:
2150    sleep_statement();
2151    break;
2152  case TOKENIZER_CLICK:
2153    click_statement();
2154    break;
2155  case TOKENIZER_PRESS:
2156    press_statement();
2157    break;
2158  case TOKENIZER_RELEASE:
2159    release_statement();
2160    break;
2161  case TOKENIZER_SHOOT:
2162    shoot_statement();
2163    break;
2164#ifdef INCLUDE_OLD_GET__SYNTAX
2165  case TOKENIZER_GET_TV96:
2166    get_tv96_statement();
2167    break;
2168  case TOKENIZER_GET_USER_TV96:
2169    get_user_tv96_statement();
2170    break;   
2171  case TOKENIZER_GET_USER_TV_ID:
2172    get_user_tv_id_statement();
2173    break;
2174  case TOKENIZER_GET_AV96:
2175    get_av96_statement();
2176    break; 
2177  case TOKENIZER_GET_USER_AV96:
2178    get_user_av96_statement();
2179    break;   
2180  case TOKENIZER_GET_USER_AV_ID:
2181    get_user_av_id_statement();
2182    break;
2183  case TOKENIZER_GET_ZOOM:
2184    get_zoom_statement();
2185    break;
2186  case TOKENIZER_GET_FOCUS:
2187    get_focus_statement();
2188    break;
2189  case TOKENIZER_GET_NEAR_LIMIT:
2190    get_near_limit_statement();
2191    break;
2192  case TOKENIZER_GET_FAR_LIMIT:
2193    get_far_limit_statement();
2194    break; 
2195  case TOKENIZER_GET_DOF:
2196    get_dof_statement();
2197    break;
2198  case TOKENIZER_GET_HYPERFOCAL_DIST:
2199    get_hyperfocal_distance_statement();
2200    break; 
2201  case TOKENIZER_GET_ISO_MARKET:
2202    get_iso_market_statement();
2203    break;
2204  case TOKENIZER_GET_ISO_REAL:
2205    get_iso_real_statement();
2206    break;
2207  case TOKENIZER_GET_BV96:
2208    get_bv96_statement();
2209    break; 
2210  case TOKENIZER_GET_SV96:
2211    get_sv96_statement();
2212    break;   
2213  case TOKENIZER_GET_ISO_MODE:
2214    get_iso_mode_statement();
2215    break;
2216  case TOKENIZER_GET_VBATT:
2217    get_vbatt_statement();
2218    break;
2219  case TOKENIZER_GET_DISK_SIZE:
2220    get_disk_size_statement();
2221    break;
2222  case TOKENIZER_GET_FREE_DISK_SPACE:
2223    get_free_disk_space_statement();
2224    break;
2225  case TOKENIZER_GET_JPG_COUNT:
2226    get_jpg_count_statement();
2227    break;
2228  case TOKENIZER_GET_RAW_COUNT:
2229    get_raw_count_statement();
2230    break;
2231  case TOKENIZER_GET_PROP:
2232    get_prop_statement();
2233    break;
2234#endif
2235  case TOKENIZER_SET_TV96_DIRECT:
2236    set_tv96_direct_statement();
2237    break;   
2238  case TOKENIZER_SET_TV96:
2239    set_tv96_statement();
2240    break; 
2241  case TOKENIZER_PLAY_SOUND:
2242    play_sound_statement();
2243    break; 
2244  case TOKENIZER_SET_SHUTTER_SPEED:
2245    set_shutter_speed_statement();
2246    break;   
2247  case TOKENIZER_SET_USER_TV96:
2248    set_user_tv96_statement();
2249    break;   
2250  case TOKENIZER_SET_USER_TV_BY_ID:
2251    set_user_tv_by_id_statement();
2252    break;
2253  case TOKENIZER_SET_USER_TV_BY_ID_REL:
2254    set_user_tv_by_id_rel_statement();
2255    break;
2256  case TOKENIZER_SET_AV96_DIRECT:
2257    set_av96_direct_statement();
2258    break;   
2259  case TOKENIZER_SET_AV96:
2260    set_av96_statement();
2261    break; 
2262   
2263  case TOKENIZER_SET_USER_AV96:
2264    set_user_av96_statement();
2265    break;   
2266  case TOKENIZER_SET_USER_AV_BY_ID:
2267    set_user_av_by_id_statement();
2268    break;
2269  case TOKENIZER_SET_USER_AV_BY_ID_REL:
2270    set_user_av_by_id_rel_statement();
2271    break;
2272   
2273  case TOKENIZER_SET_ND_FILTER:
2274    set_nd_filter_statement();
2275    break; 
2276 
2277  case TOKENIZER_SET_ZOOM:
2278    set_zoom_statement();
2279    break;
2280  case TOKENIZER_SET_ZOOM_REL:
2281    set_zoom_rel_statement();
2282    break;
2283  case TOKENIZER_SET_ZOOM_SPEED:
2284    set_zoom_speed_statement();
2285    break;
2286
2287  case TOKENIZER_SET_FOCUS:
2288    set_focus_statement();
2289    break;
2290  //ARM Begin
2291  /*case TOKENIZER_SET_ISO_MARKET:
2292    set_iso_market_statement();
2293    break;
2294  case TOKENIZER_SET_ISO_DL_F_B:
2295    set_iso_real_delta_from_base_statement();
2296    break;*/ 
2297  case TOKENIZER_SET_ISO_REAL:
2298    set_iso_real_statement();
2299    break;
2300  case TOKENIZER_SET_SV96:
2301    set_sv96_statement();
2302    break; 
2303 
2304  //ARM End
2305 
2306   
2307
2308  case TOKENIZER_SET_ISO_MODE:
2309    set_iso_mode_statement();
2310    break;
2311
2312  case TOKENIZER_SET_PROP:
2313    set_prop_statement();
2314    break;
2315  case TOKENIZER_SET_LED:
2316    set_led_statement();
2317    break;
2318
2319  case TOKENIZER_SET_EV:
2320        set_ev_statement();
2321   break;
2322   
2323    case TOKENIZER_SET_MOVIE_STATUS:
2324        set_movie_status_statement();
2325   break;
2326   case TOKENIZER_SET_RESOLUTION:
2327        set_resolution_statement();
2328   break;
2329   case TOKENIZER_SET_QUALITY:
2330        set_quality_statement();
2331   break;
2332
2333  case TOKENIZER_WAIT_CLICK:
2334    wait_click_statement();
2335    break;
2336  case TOKENIZER_IS_KEY:
2337    is_key_statement();
2338    break;
2339
2340  case TOKENIZER_WHEEL_LEFT:
2341    wheel_left_statement();
2342    break;
2343  case TOKENIZER_WHEEL_RIGHT:
2344    wheel_right_statement();
2345    break;
2346
2347  case TOKENIZER_IF:
2348    if_statement();
2349    break;
2350  case TOKENIZER_ELSE:
2351    else_statement();
2352    break;
2353  case TOKENIZER_ENDIF:
2354    endif_statement();
2355    break;
2356  case TOKENIZER_SELECT:
2357    select_statement();
2358    break;
2359  case TOKENIZER_CASE:
2360    case_statement();
2361    break;
2362  case TOKENIZER_CASE_ELSE:
2363    case_else_statement();
2364    break;
2365  case TOKENIZER_GOTO:
2366    goto_statement();
2367    break;
2368  case TOKENIZER_GOSUB:
2369    gosub_statement();
2370    break;
2371  case TOKENIZER_RETURN:
2372    return_statement();
2373    break;
2374  case TOKENIZER_FOR:
2375    for_statement();
2376    break;
2377  case TOKENIZER_NEXT:
2378    next_statement();
2379    break;
2380  case TOKENIZER_DO:
2381    do_statement();
2382    break;
2383  case TOKENIZER_UNTIL:
2384    until_statement();
2385    break;
2386  case TOKENIZER_WHILE:
2387    while_statement();
2388    break;
2389  case TOKENIZER_WEND:
2390    wend_statement();
2391    break;
2392  case TOKENIZER_END:
2393    end_statement();
2394    break;
2395  case TOKENIZER_LET:
2396    accept(TOKENIZER_LET);
2397    /* Fall through. */
2398  case TOKENIZER_VARIABLE:
2399    let_statement();
2400    break;
2401  case TOKENIZER_REM:
2402    rem_statement();
2403    break;
2404  case TOKENIZER_CLS:
2405    cls_statement();
2406    break;
2407  case TOKENIZER_SET_RAW:
2408    set_raw_statement();
2409    break;
2410  case TOKENIZER_SET_RAW_NR:
2411    set_raw_nr_statement();
2412    break;
2413  case TOKENIZER_SET_SCRIPT_AUTOSTART:
2414    set_autostart_statement();
2415    break;
2416  case TOKENIZER_EXIT_ALT:
2417    exit_alt_statement();
2418    break;
2419  case TOKENIZER_SHUT_DOWN:
2420    shutdown_statement();
2421    break;
2422  case TOKENIZER_SET_BACKLIGHT:
2423    set_backlight_statement();
2424    break;
2425
2426// >> mx3 . motion detector
2427        case   TOKENIZER_MD_DETECT_MOTION:
2428                md_detect_motion_statement();
2429                break;
2430        case  TOKENIZER_MD_GET_CELL_DIFF:
2431                md_get_cell_diff_statement();
2432                break;
2433// << mx3 . motion_detector
2434
2435  case TOKENIZER_SHOT_HISTO_ENABLE:
2436    shot_histo_enable_statement();
2437    break;
2438
2439  case TOKENIZER_SET_RECORD:
2440    set_record_statement();
2441    break;
2442
2443  default:
2444    DEBUG_PRINTF("ubasic.c: statement(): not implemented %d\n", token);
2445    ended = 1;
2446    ubasic_error = UBASIC_E_UNK_STATEMENT;
2447  }
2448}
2449/*---------------------------------------------------------------------------*/
2450static void
2451line_statement(void)
2452{
2453  /* line numbers have been removed */
2454  DEBUG_PRINTF("----------- Line number %d ---------\n", tokenizer_line_number());
2455  /*    current_linenum = tokenizer_num();*/
2456#if 0
2457  if (tokenizer_token() == TOKENIZER_LABEL) {
2458#ifdef DEBUG
2459      tokenizer_label(string, sizeof(string));
2460      DEBUG_PRINTF("line_statement: label: %s\n", string );
2461#endif
2462      accept(TOKENIZER_LABEL);
2463      accept(TOKENIZER_CR);
2464      return;
2465  }
2466#endif
2467  /* reyalp - eat up to 100 labels or rems at a time so they don't cost 10ms each */
2468  int count = 100;
2469  do {
2470    int r=tokenizer_token();
2471    if ( r == TOKENIZER_LABEL ) {
2472      /* hit limit and we are on a label, return */
2473      if( count == 1 )
2474        return;
2475#ifdef DEBUG
2476      tokenizer_label(string, sizeof(string));
2477      DEBUG_PRINTF("line_statement: label: %s\n", string );
2478#endif
2479      accept(TOKENIZER_LABEL);
2480      accept(TOKENIZER_CR);
2481    }
2482    else if ( r == TOKENIZER_REM ) {
2483      rem_statement();
2484    }
2485  } while(--count);
2486  statement();
2487  return;
2488}
2489/*---------------------------------------------------------------------------*/
2490void
2491ubasic_run(void)
2492{
2493  if(tokenizer_finished()) {
2494    DEBUG_PRINTF("uBASIC program finished\n");
2495    return;
2496  }
2497
2498  line_statement();
2499}
2500/*---------------------------------------------------------------------------*/
2501int
2502ubasic_finished(void)
2503{
2504  return ended || tokenizer_finished();
2505}
2506/*---------------------------------------------------------------------------*/
2507void
2508ubasic_set_variable(int varnum, int value)
2509{
2510  if(varnum >= 0 && varnum < MAX_VARNUM) {
2511    variables[varnum] = value;
2512  }
2513}
2514/*---------------------------------------------------------------------------*/
2515int
2516ubasic_get_variable(int varnum)
2517{
2518  if(varnum >= 0 && varnum < MAX_VARNUM) {
2519    return variables[varnum];
2520  }
2521  return 0;
2522}
2523/*---------------------------------------------------------------------------*/
2524void
2525ubasic_end() {
2526}
2527/*---------------------------------------------------------------------------*/
2528
2529
2530
2531
2532
2533
2534
Note: See TracBrowser for help on using the repository browser.