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

Revision 524, 61.2 KB checked in by reyalp, 5 years ago (diff)
  • made ubasic eat up to 100 labels or REMs in one call to ubasic_run, rather than taking 10ms each
  • made script buffer dynamic, allocated when script is loaded
  • made some other script related memory dynamic

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