source: branches/juciphox/lib/ubasic/ubasic.c @ 453

Revision 453, 50.9 KB checked in by phyrephox, 5 years ago (diff)

+ added fast movie switches:
it is now possible to quickly change video quality during recording via the up/down buttons
also you can pause a movie by pressing left, unpause it by pressing right
for this feature a new option has been added to the video override menu.

drawbacks: there is no visual feedback yet on quality change/pause/unpause functions
+ new ubasic command: set_movie_status. If you set it to 1, movie will be paused. 2 will unpause movie and 3 will stop movie.

needs proper testing, proper visual representation

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