Implemented numbers with different bases

src/build/core/ExpressionToRegister.go

@@ -1,8 +1,6 @@
 package core
 
 import (
-	"fmt"
-
 	"git.akyoto.dev/cli/q/src/build/asm"
 	"git.akyoto.dev/cli/q/src/build/ast"
 	"git.akyoto.dev/cli/q/src/build/cpu"
@@ -28,7 +26,6 @@ func (f *Function) ExpressionToRegister(node *expression.Expression, register cp
 
 	if len(node.Children) == 1 {
 		if !node.Token.IsUnaryOperator() {
-			fmt.Println(node.String(f.File.Bytes), node.Token.Kind)
 			return errors.New(errors.MissingOperand, f.File, node.Token.End())
 		}
 

src/build/core/Number.go

@@ -2,6 +2,7 @@ package core
 
 import (
 	"strconv"
+	"strings"
 	"unicode/utf8"
 
 	"git.akyoto.dev/cli/q/src/build/errors"
@@ -12,7 +13,24 @@ import (
 func (f *Function) Number(t token.Token) (int, byte, error) {
 	switch t.Kind {
 	case token.Number:
-		number, err := strconv.Atoi(t.Text(f.File.Bytes))
+		digits := t.Text(f.File.Bytes)
+
+		if strings.HasPrefix(digits, "0x") {
+			number, err := strconv.ParseInt(digits[2:], 16, 64)
+			return int(number), 8, err
+		}
+
+		if strings.HasPrefix(digits, "0o") {
+			number, err := strconv.ParseInt(digits[2:], 8, 64)
+			return int(number), 8, err
+		}
+
+		if strings.HasPrefix(digits, "0b") {
+			number, err := strconv.ParseInt(digits[2:], 2, 64)
+			return int(number), 8, err
+		}
+
+		number, err := strconv.Atoi(digits)
 		return number, 8, err
 
 	case token.Rune:

src/build/token/Tokenize.go

@@ -94,6 +94,38 @@ func Tokenize(buffer []byte) List {
 			tokens = append(tokens, Token{Kind: kind, Position: start, Length: Length(end - start)})
 			continue
 
+		case '0':
+			position := i
+			i++
+
+			if i >= Position(len(buffer)) {
+				tokens = append(tokens, Token{Kind: Number, Position: position, Length: 1})
+				break
+			}
+
+			filter := isDigit
+
+			switch buffer[i] {
+			case 'x':
+				i++
+				filter = isHexDigit
+
+			case 'b':
+				i++
+				filter = isBinaryDigit
+
+			case 'o':
+				i++
+				filter = isOctalDigit
+			}
+
+			for i < Position(len(buffer)) && filter(buffer[i]) {
+				i++
+			}
+
+			tokens = append(tokens, Token{Kind: Number, Position: position, Length: Length(i - position)})
+			continue
+
 		default:
 			if isIdentifierStart(buffer[i]) {
 				position := i
@@ -123,11 +155,11 @@ func Tokenize(buffer []byte) List {
 				continue
 			}
 
-			if isNumber(buffer[i]) {
+			if isDigit(buffer[i]) {
 				position := i
 				i++
 
-				for i < Position(len(buffer)) && isNumber(buffer[i]) {
+				for i < Position(len(buffer)) && isDigit(buffer[i]) {
 					i++
 				}
 
@@ -235,7 +267,7 @@ func Tokenize(buffer []byte) List {
 }
 
 func isIdentifier(c byte) bool {
-	return isLetter(c) || isNumber(c) || c == '_'
+	return isLetter(c) || isDigit(c) || c == '_'
 }
 
 func isIdentifierStart(c byte) bool {
@@ -246,8 +278,20 @@ func isLetter(c byte) bool {
 	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
 }
 
-func isNumber(c byte) bool {
-	return (c >= '0' && c <= '9')
+func isDigit(c byte) bool {
+	return c >= '0' && c <= '9'
+}
+
+func isHexDigit(c byte) bool {
+	return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F')
+}
+
+func isBinaryDigit(c byte) bool {
+	return c == '0' || c == '1'
+}
+
+func isOctalDigit(c byte) bool {
+	return c >= '0' && c <= '7'
 }
 
 func isOperator(c byte) bool {

src/build/token/Tokenize_test.go

@@ -179,6 +179,71 @@ func TestNegateNumber(t *testing.T) {
 	}
 }
 
+func TestBinaryNumber(t *testing.T) {
+	tokens := token.Tokenize([]byte(`0b1010`))
+
+	expected := []token.Kind{
+		token.Number,
+		token.EOF,
+	}
+
+	for i, kind := range expected {
+		assert.Equal(t, tokens[i].Kind, kind)
+	}
+}
+
+func TestOctalNumber(t *testing.T) {
+	tokens := token.Tokenize([]byte(`0o755`))
+
+	expected := []token.Kind{
+		token.Number,
+		token.EOF,
+	}
+
+	for i, kind := range expected {
+		assert.Equal(t, tokens[i].Kind, kind)
+	}
+}
+
+func TestHexadecimalNumber(t *testing.T) {
+	tokens := token.Tokenize([]byte(`0xCAFE`))
+
+	expected := []token.Kind{
+		token.Number,
+		token.EOF,
+	}
+
+	for i, kind := range expected {
+		assert.Equal(t, tokens[i].Kind, kind)
+	}
+}
+
+func TestStandaloneZero(t *testing.T) {
+	tokens := token.Tokenize([]byte(`0`))
+
+	expected := []token.Kind{
+		token.Number,
+		token.EOF,
+	}
+
+	for i, kind := range expected {
+		assert.Equal(t, tokens[i].Kind, kind)
+	}
+}
+
+func TestLeadingZero(t *testing.T) {
+	tokens := token.Tokenize([]byte(`0123`))
+
+	expected := []token.Kind{
+		token.Number,
+		token.EOF,
+	}
+
+	for i, kind := range expected {
+		assert.Equal(t, tokens[i].Kind, kind)
+	}
+}
+
 func TestOperatorAssign(t *testing.T) {
 	tokens := token.Tokenize([]byte(`a += b -= c *= d /= e &= f |= g ^= h <<= i >>= j`))