CHDK_DE Vorschauversion  Trunk Rev. 5209
 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 303 der Datei tokenizer.c.

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

Definiert in Zeile 268 der Datei tokenizer.c.

269 {
270  if(*ptr == '\n') {
271  return TOKENIZER_CR;
272  } else if(*ptr == ',') {
273  return TOKENIZER_COMMA;
274  } else if(*ptr == ';') {
275  return TOKENIZER_SEMICOLON;
276  } else if(*ptr == '+') {
277  return TOKENIZER_PLUS;
278  } else if(*ptr == '-') {
279  return TOKENIZER_MINUS;
280  } else if(*ptr == '&') {
281  return TOKENIZER_AND;
282  } else if(*ptr == '|') {
283  return TOKENIZER_OR;
284  } else if(*ptr == '^') {
285  return TOKENIZER_XOR;
286  } else if(*ptr == '*') {
287  return TOKENIZER_ASTR;
288  } else if(*ptr == '/') {
289  return TOKENIZER_SLASH;
290  } else if(*ptr == '%') {
291  return TOKENIZER_MOD;
292  } else if(*ptr == '(') {
293  return TOKENIZER_LEFTPAREN;
294  } else if(*ptr == ')') {
295  return TOKENIZER_RIGHTPAREN;
296  } else if(*ptr == '=') {
297  return TOKENIZER_EQ;
298  }
299  return 0;
300 }
void tokenizer_error_print ( void  )

Definiert in Zeile 473 der Datei tokenizer.c.

474 {
475  DEBUG_PRINTF("tokenizer_error_print: '%s'\n", ptr);
476 }
int tokenizer_finished ( void  )

Definiert in Zeile 479 der Datei tokenizer.c.

480 {
481  return *ptr == 0 || current_token == TOKENIZER_ENDOFINPUT;
482 }
void tokenizer_init ( const char *  program)

Definiert in Zeile 390 der Datei tokenizer.c.

391 {
392  ptr = program;
393  current_line = 1;
396 }
void tokenizer_label ( char *  dest,
int  len 
)

Definiert in Zeile 450 der Datei tokenizer.c.

451 {
452  char *string_end;
453  int string_len;
454 
456  return;
457  }
458  // allow string \r, \n, tabulation and space to end labels
459  string_end = strpbrk(ptr + 1, " \t\r\n");
460 
461  if(string_end == NULL) {
462  return;
463  }
464  string_len = string_end - ptr - 1;
465  if(len < string_len) {
466  string_len = len;
467  }
468  memcpy(dest, ptr + 1, string_len);
469  dest[string_len] = 0;
470 }
int tokenizer_line_number ( void  )

Definiert in Zeile 490 der Datei tokenizer.c.

491 {
492  return current_line;
493 }
void tokenizer_next ( void  )

Definiert in Zeile 405 der Datei tokenizer.c.

406 {
407 
408  if(tokenizer_finished()) {
409  return;
410  }
411 
412  DEBUG_PRINTF("tokenizer_next: %p\n", nextptr);
413  ptr = nextptr;
414  while((*ptr == ' ') || (*ptr == '\t')) {
415  ++ptr;
416  }
418  DEBUG_PRINTF("tokenizer_next: '%s' %d\n", ptr, current_token);
419  return;
420 }
int tokenizer_num ( void  )

Definiert in Zeile 423 der Datei tokenizer.c.

424 {
425  return atoi(ptr);
426 }
void tokenizer_string ( char *  dest,
int  len 
)

Definiert in Zeile 429 der Datei tokenizer.c.

430 {
431  char *string_end;
432  int string_len;
433 
435  return;
436  }
437  string_end = strchr(ptr + 1, '"');
438  if(string_end == NULL) {
439  return;
440  }
441  string_len = string_end - ptr - 1;
442  if(len < string_len) {
443  string_len = len;
444  }
445  memcpy(dest, ptr + 1, string_len);
446  dest[string_len] = 0;
447 }
int tokenizer_token ( void  )

Definiert in Zeile 399 der Datei tokenizer.c.

400 {
401  return current_token;
402 }
int tokenizer_variable_num ( void  )

Definiert in Zeile 485 der Datei tokenizer.c.

486 {
487  return *ptr - (*ptr>='a'?'a':('A'-26));
488 }

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.