lexer.c File Reference

#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cqueue.h"
#include "debug.h"
#include "dstring.h"
#include "module.h"
#include "token.h"
#include "types/err.h"
#include "types/keywords.h"
#include "types/operators.h"

Include dependency graph for lexer.c:

Go to the source code of this file.

Macros
#define	MOD_ADD(lexeme, type)

Functions
error_code_t	mya_lexer (module_t *module)
	Make the lexical analysis on the given module.

Macro Definition Documentation

MOD_ADD

#define MOD_ADD	(		lexeme,
			type )

Value:

  token = module_add_token(module);                                                                                    \
  token_init(token, lexeme, type, line, column);                                                                       \
  DPRINTF3("Added token `%s` at %s:%d:%d.\n", lexeme, module->filepath, line, column)

Definition at line 47 of file lexer.c.

#define MOD_ADD(lexeme, type)                                                                                          \
  token = module_add_token(module);                                                                                    \
  token_init(token, lexeme, type, line, column);                                                                       \
  DPRINTF3("Added token `%s` at %s:%d:%d.\n", lexeme, module->filepath, line, column)

Function Documentation

mya_lexer()

error_code_t mya_lexer

(

module_t *

module

)

Make the lexical analysis on the given module.

It will construct the module->tokens list and maybe registry some errors on module->errors list.

Parameters

module

The module for make the lexical analysis.

Returns

ERR_INVALID_CODE on lexer found some errors on module.

ERR_OK on finished successful.

Definition at line 53 of file lexer.c.

{
  char message[128];
  int ch;
  unsigned int line = 1;
  unsigned int column = 1;
  token_t* token;
 
  for (; module_lookup(module, &ch, 0) == ERR_OK; column++) {
    if (isblank(ch)) {
      module_getc(module, &ch);
      continue;
    }
 
    switch (ch) {
    case '#':
      _mod_rm_line(module);
      line++;
      column = 0;
      continue;
    case '\n':
      line++;
      column = 0;
      break;
    case '{':
      MOD_ADD("{", TK_OPEN_BRACES);
      break;
    case '}':
      MOD_ADD("}", TK_CLOSE_BRACES);
      break;
    case '(':
      MOD_ADD("(", TK_OPEN_PARENS);
      break;
    case ')':
      MOD_ADD(")", TK_CLOSE_PARENS);
      break;
    case '[':
      MOD_ADD("[", TK_OPEN_BRACKET);
      break;
    case ']':
      MOD_ADD("]", TK_CLOSE_BRACKET);
      break;
    case ';':
      MOD_ADD(";", TK_SEMICOLON);
      break;
    case ':':
      MOD_ADD(":", TK_COLON);
      break;
    case ',':
      MOD_ADD(",", TK_COMMA);
      break;
    case '=':
      MOD_ADD("=", TK_EQUAL);
      break;
    case '"':
      column += _mod_read_string(module, line, column) - 1;
      continue;
    default:
      if (isdigit(ch)) {
        column += _mod_read_number(module, line, column) - 1;
        continue;
      }
 
      if (ispunct(ch)) {
        column += _mod_read_operator(module, line, column) - 1;
        continue;
      }
 
      if (isalnum(ch)) {
        column += _mod_read_identifier(module, line, column) - 1;
        continue;
      }
 
      sprintf(message, "Character '%c' is unexpected here!\n", ch);
 
      module_add_error(module, line, column, 1, message);
      break;
    }
 
    module_getc(module, &ch);
  }
 
  MOD_ADD(":EOF:", TK_EOF);
 
  return (module->errors_count == 0) ? ERR_OK : ERR_INVALID_CODE;
}