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

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

Definiert in Zeile 275 der Datei tokenizer.c.

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

Definiert in Zeile 480 der Datei tokenizer.c.

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

Definiert in Zeile 486 der Datei tokenizer.c.

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

Definiert in Zeile 397 der Datei tokenizer.c.

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

Definiert in Zeile 457 der Datei tokenizer.c.

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

Definiert in Zeile 497 der Datei tokenizer.c.

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

Definiert in Zeile 412 der Datei tokenizer.c.

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

Definiert in Zeile 430 der Datei tokenizer.c.

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

Definiert in Zeile 436 der Datei tokenizer.c.

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

Definiert in Zeile 406 der Datei tokenizer.c.

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

Definiert in Zeile 492 der Datei tokenizer.c.

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

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.