CHDK_DE Vorschauversion  Trunk Rev. 5573
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
tokenizer.c-Dateireferenz
#include "tokenizer.h"
#include "stdlib.h"
+ Include-Abhängigkeitsdiagramm für tokenizer.c:

gehe zum Quellcode dieser Datei

Datenstrukturen

struct  keyword_token
 

Makrodefinitionen

#define DEBUG_PRINTF(...)
 
#define MAX_NUMLEN   6
 

Funktionen

static int singlechar (void)
 
static int get_next_token (void)
 
void tokenizer_init (const char *program)
 
int tokenizer_token (void)
 
void tokenizer_next (void)
 
int tokenizer_num (void)
 
void tokenizer_string (char *dest, int len)
 
void tokenizer_label (char *dest, int len)
 
void tokenizer_error_print (void)
 
int tokenizer_finished (void)
 
int tokenizer_variable_num (void)
 
int tokenizer_line_number (void)
 

Variablen

static char constptr
 
static char constnextptr
 
static ubasic_token current_token = TOKENIZER_ERROR
 
static int current_line = 0
 
static struct keyword_token keywords []
 

Makro-Dokumentation

#define DEBUG_PRINTF (   ...)

Definiert in Zeile 34 der Datei tokenizer.c.

#define MAX_NUMLEN   6

Definiert in Zeile 48 der Datei tokenizer.c.

Dokumentation der Funktionen

static int get_next_token ( void  )
static

Definiert in Zeile 311 der Datei tokenizer.c.

312 {
313  struct keyword_token const *kt;
314  int i;
315 
316  DEBUG_PRINTF("get_next_token(): '%s'\n", ptr);
317 
318  // eat all whitespace
319  while(*ptr == ' ' || *ptr == '\t' || *ptr == '\r') ptr++;
320 
321  if(*ptr == 0) {
322  return TOKENIZER_ENDOFINPUT;
323  }
324 
325  // UnknStatement should have size, otherwise hanging-up in ubasic.c possible for some cases
326  nextptr = ptr + 1;
327 
328  if(isdigit(*ptr)) {
329  for(i = 0; i < (MAX_NUMLEN+1); ++i) {
330  if(!isdigit(ptr[i])) {
331  if(i > 0) {
332  nextptr = ptr + i;
333  return TOKENIZER_NUMBER;
334  } else {
335  DEBUG_PRINTF("get_next_token: error due to too short number\n");
336  return TOKENIZER_ERROR;
337  }
338  }
339  if(!isdigit(ptr[i])) {
340  DEBUG_PRINTF("get_next_token: error due to malformed number\n");
341  return TOKENIZER_ERROR;
342  }
343  }
344  DEBUG_PRINTF("get_next_token: error due to too long number\n");
345  return TOKENIZER_ERROR;
346  } else if(*ptr == ':') {
347  // label
348  nextptr = ptr;
349  do {
350  ++nextptr;
351  } while(*nextptr != ' ' && *nextptr != '\r' && *nextptr != '\n' && *nextptr != '\t');
352  return TOKENIZER_LABEL;
353  } else if((i=singlechar()) != 0) {
354  if (i == TOKENIZER_CR){
355  // move to next line, and skip all following empty lines as well
356  while (singlechar() == TOKENIZER_CR)
357  {
358  current_line++;
359  ptr++;
360  // eat all whitespace
361  while(*ptr == ' ' || *ptr == '\t' || *ptr == '\r') ptr++;
362  };
363  ptr--;
364  // dangelo: now the last char might point to a whitespace instead of
365  // a CR. I hope that doesn't break anything.
366  }
367  nextptr = ptr + 1;
368  return i;
369  } else if(*ptr == '"') {
370  nextptr = ptr;
371  do {
372  ++nextptr;
373  } while(*nextptr != '"');
374  ++nextptr;
375  return TOKENIZER_STRING;
376  } else {
377  for(kt = keywords; kt->keyword != NULL; ++kt) {
378  if(strncmp(ptr, kt->keyword, strlen(kt->keyword)) == 0) {
379  nextptr = ptr + strlen(kt->keyword);
380  if (kt->token == TOKENIZER_REM) {
381  while(*nextptr != 0 && *nextptr != '\r' && *nextptr != '\n') ++nextptr;
382  }
383  return kt->token;
384  }
385  }
386  }
387 
388  if((*ptr >= 'a' && *ptr <= 'z') || (*ptr >= 'A' && *ptr <= 'Z')) {
389  nextptr = ptr + 1;
390  return TOKENIZER_VARIABLE;
391  }
392 
393 
394  return TOKENIZER_ERROR;
395 }
static int singlechar ( void  )
static

Definiert in Zeile 276 der Datei tokenizer.c.

277 {
278  if(*ptr == '\n') {
279  return TOKENIZER_CR;
280  } else if(*ptr == ',') {
281  return TOKENIZER_COMMA;
282  } else if(*ptr == ';') {
283  return TOKENIZER_SEMICOLON;
284  } else if(*ptr == '+') {
285  return TOKENIZER_PLUS;
286  } else if(*ptr == '-') {
287  return TOKENIZER_MINUS;
288  } else if(*ptr == '&') {
289  return TOKENIZER_AND;
290  } else if(*ptr == '|') {
291  return TOKENIZER_OR;
292  } else if(*ptr == '^') {
293  return TOKENIZER_XOR;
294  } else if(*ptr == '*') {
295  return TOKENIZER_ASTR;
296  } else if(*ptr == '/') {
297  return TOKENIZER_SLASH;
298  } else if(*ptr == '%') {
299  return TOKENIZER_MOD;
300  } else if(*ptr == '(') {
301  return TOKENIZER_LEFTPAREN;
302  } else if(*ptr == ')') {
303  return TOKENIZER_RIGHTPAREN;
304  } else if(*ptr == '=') {
305  return TOKENIZER_EQ;
306  }
307  return 0;
308 }
void tokenizer_error_print ( void  )

Definiert in Zeile 481 der Datei tokenizer.c.

482 {
483  DEBUG_PRINTF("tokenizer_error_print: '%s'\n", ptr);
484 }
int tokenizer_finished ( void  )

Definiert in Zeile 487 der Datei tokenizer.c.

488 {
489  return *ptr == 0 || current_token == TOKENIZER_ENDOFINPUT;
490 }
void tokenizer_init ( const char *  program)

Definiert in Zeile 398 der Datei tokenizer.c.

399 {
400  ptr = program;
401  current_line = 1;
404 }
void tokenizer_label ( char *  dest,
int  len 
)

Definiert in Zeile 458 der Datei tokenizer.c.

459 {
460  char *string_end;
461  int string_len;
462 
464  return;
465  }
466  // allow string \r, \n, tabulation and space to end labels
467  string_end = strpbrk(ptr + 1, " \t\r\n");
468 
469  if(string_end == NULL) {
470  return;
471  }
472  string_len = string_end - ptr - 1;
473  if(len < string_len) {
474  string_len = len;
475  }
476  memcpy(dest, ptr + 1, string_len);
477  dest[string_len] = 0;
478 }
int tokenizer_line_number ( void  )

Definiert in Zeile 498 der Datei tokenizer.c.

499 {
500  return current_line;
501 }
void tokenizer_next ( void  )

Definiert in Zeile 413 der Datei tokenizer.c.

414 {
415 
416  if(tokenizer_finished()) {
417  return;
418  }
419 
420  DEBUG_PRINTF("tokenizer_next: %p\n", nextptr);
421  ptr = nextptr;
422  while((*ptr == ' ') || (*ptr == '\t')) {
423  ++ptr;
424  }
426  DEBUG_PRINTF("tokenizer_next: '%s' %d\n", ptr, current_token);
427  return;
428 }
int tokenizer_num ( void  )

Definiert in Zeile 431 der Datei tokenizer.c.

432 {
433  return atoi(ptr);
434 }
void tokenizer_string ( char *  dest,
int  len 
)

Definiert in Zeile 437 der Datei tokenizer.c.

438 {
439  char *string_end;
440  int string_len;
441 
443  return;
444  }
445  string_end = strchr(ptr + 1, '"');
446  if(string_end == NULL) {
447  return;
448  }
449  string_len = string_end - ptr - 1;
450  if(len < string_len) {
451  string_len = len;
452  }
453  memcpy(dest, ptr + 1, string_len);
454  dest[string_len] = 0;
455 }
int tokenizer_token ( void  )

Definiert in Zeile 407 der Datei tokenizer.c.

408 {
409  return current_token;
410 }
int tokenizer_variable_num ( void  )

Definiert in Zeile 493 der Datei tokenizer.c.

494 {
495  return *ptr - (*ptr>='a'?'a':('A'-26));
496 }

Variablen-Dokumentation

int current_line = 0
static

Definiert in Zeile 56 der Datei tokenizer.c.

ubasic_token current_token = TOKENIZER_ERROR
static

Definiert in Zeile 55 der Datei tokenizer.c.

struct keyword_token keywords[]
static

Definiert in Zeile 58 der Datei tokenizer.c.

char const * nextptr
static

Definiert in Zeile 46 der Datei tokenizer.c.

char const* ptr
static

Definiert in Zeile 46 der Datei tokenizer.c.