CHDK_DE Vorschauversion  Trunk Rev. 5846
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
tokenizer.c-Dateireferenz
#include "stdlib.h"
#include "stddef.h"
#include "string.h"
#include "ctype.h"
#include "stdio.h"
#include "tokenizer.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 47 der Datei tokenizer.c.

Dokumentation der Funktionen

static int get_next_token ( void  )
static

Definiert in Zeile 312 der Datei tokenizer.c.

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

Definiert in Zeile 277 der Datei tokenizer.c.

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

Definiert in Zeile 482 der Datei tokenizer.c.

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

Definiert in Zeile 488 der Datei tokenizer.c.

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

Definiert in Zeile 399 der Datei tokenizer.c.

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

Definiert in Zeile 459 der Datei tokenizer.c.

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

Definiert in Zeile 499 der Datei tokenizer.c.

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

Definiert in Zeile 414 der Datei tokenizer.c.

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

Definiert in Zeile 432 der Datei tokenizer.c.

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

Definiert in Zeile 438 der Datei tokenizer.c.

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

Definiert in Zeile 408 der Datei tokenizer.c.

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

Definiert in Zeile 494 der Datei tokenizer.c.

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

Variablen-Dokumentation

int current_line = 0
static

Definiert in Zeile 55 der Datei tokenizer.c.

ubasic_token current_token = TOKENIZER_ERROR
static

Definiert in Zeile 54 der Datei tokenizer.c.

struct keyword_token keywords[]
static

Definiert in Zeile 57 der Datei tokenizer.c.

char const * nextptr
static

Definiert in Zeile 45 der Datei tokenizer.c.

char const* ptr
static

Definiert in Zeile 45 der Datei tokenizer.c.