FilesExpand file tree

 master

/

lambda.scanner.h

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

127 lines (91 loc) · 1.98 KB

 master

/

lambda.scanner.h

Copy path

Top

File metadata and controls

• Code
• Blame

127 lines (91 loc) · 1.98 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

#ifndef __lambda__lambda_scanner__

#define __lambda__lambda_scanner__

#include <vector>

#include <string>

#include <memory>

#include <map>

namespace lambda

{

enum tokenType

{

TOKEN_INTEGER = 'i',

TOKEN_FLOAT = 'f',

TOKEN_LPAREN = '(',

TOKEN_RPAREN = ')',

TOKEN_EOF = 'e',

TOKEN_ERROR = 'E',

TOKEN_SYMBOL = 'S'

};

typedef std::shared_ptr<std::string> String;

String &getString(const char *c);

const char* getStringPtr(const char *c);

class token

{

public:

token(tokenType in_t);

void print();

virtual ~token() {}

int line, column;

tokenType getType() { return _t; }

virtual double floatValue() { return 0; }

virtual long long intValue() { return 0; }

virtual String stringValue() { return String(); }

protected:

virtual void printSpecial() {}

private:

tokenType _t;

};

typedef std::shared_ptr<token> Token;

class tknInteger : public token

{

public:

tknInteger(long long in_i);

virtual double floatValue() { return (double)_i; }

virtual long long intValue() { return _i; }

protected:

virtual void printSpecial();

private:

long long _i;

};

class tknFloat : public token

{

public:

tknFloat(double in_f);

virtual double floatValue() { return _f; }

virtual long long intValue() { return (long long)_f; }

protected:

virtual void printSpecial();

private:

double _f;

};

class tknSymbol : public token

{

public:

tknSymbol(String &in_str);

protected:

virtual void printSpecial();

virtual String stringValue() { return _str; }

private:

String _str;

};

class scanner

{

public:

scanner(std::string &in_str);

Token scan();

private:

bool isDigit(char c);

bool isWhite(char c);

bool isSymbol(char c);

void skipWhite();

char read();

char peek();

// Map from a string to a unique representation

std::map<std::string, String> _strs;

std::string str;

int idx;

int _line, _col;

};

typedef std::shared_ptr<scanner> Scanner;

}

#endif