SVI Перевод текста компилятора на русский язык

cmd/ouc/main.go

@@ -2,20 +2,24 @@
 package main
 
 import (
-	"log"
+	мЛог "log"
 
-	"p78git.ddns.net/svi/odeft/internal/compiler"
+	мКомпилятор "p78git.ddns.net/svi/odeft/internal/compiler"
 )
 
 func main() {
-	log.Printf("main(): Оберон-У компилятор\n")
-	app, err := compiler.NewCompiler()
-	if err != nil {
-		log.Printf("main(): in create Compiler, err=\n\t%v\n", err)
+	мЛог.Printf("main(): Оберон-У компилятор\n")
+	пуск()
+}
+
+func пуск() {
+	компилятор, ош := мКомпилятор.НовКомпилятор()
+	if ош != nil {
+		мЛог.Printf("пуск(): при создании компилятора, ош=\n\t%v\n", ош)
 		panic(1)
 	}
-	if err := app.Run(); err != nil {
-		log.Printf("main(): in run Compiler, err=\n\t%v\n", err)
+	if err := компилятор.Пуск(); err != nil {
+		мЛог.Printf("пуск(): при работе компилятора, ош=\n\t%v\n", err)
 		panic(2)
 	}
 }

dev.sh

@@ -1,4 +1,4 @@
-export SRC_MAIN="./src/main.obu"
+export SRC_MAIN="./src/main.ou"
 
 cd ./bin && \
 ./ouc_dev

internal/compiler/compiler.go

@@ -2,74 +2,79 @@
 package compiler
 
 import (
-	"fmt"
-	"log"
-	"os"
+	мФорм "fmt"
+	мЛог "log"
+	мОс "os"
 
+	"p78git.ddns.net/svi/odeft/internal/src_rune"
 	"p78git.ddns.net/svi/odeft/internal/syntax"
 )
 
-// Compiler -- главный тип сервиса компилятора
-type Compiler struct {
-	syntax *syntax.Syntax
+// Компилятор -- главный тип сервиса компилятора
+type Компилятор struct {
+	syntax *syntax.Синтаксис
 }
 
-// NewCompiler -- возвращает новый тип компилятора
-func NewCompiler() (*Compiler, error) {
-	log.Printf("NewCompiler()\n")
-	sf := &Compiler{}
+// НовКомпилятор -- возвращает новый тип компилятора
+func НовКомпилятор() (*Компилятор, error) {
+	мЛог.Printf("НовКомпилятор()\n")
+	сам := &Компилятор{}
 
-	srcMain, err := sf.getMainModule()
-	if err != nil {
-		return nil, fmt.Errorf("NewCompiler(): in get main module, err=\n\t%w", err)
+	исхГлавИмя, ош := сам.главМодульПолуч()
+	if ош != nil {
+		return nil, мФорм.Errorf("НовКомпилятор(): при получении главного модуля, ош\n\t%w", ош)
 	}
-	textSrc, err := sf.readMainModule(srcMain)
-	if err != nil {
-		return nil, fmt.Errorf("NewCompiler(): in read main module(%v), err=\n\t%w", srcMain, err)
+	исхГлавТекст, ош := сам.исхГлавЧитать(исхГлавИмя)
+	if ош != nil {
+		return nil, мФорм.Errorf("НовКомпилятор(): in read main module(%v), ош=\n\t%w", исхГлавТекст, ош)
 	}
-	runeSrc := []rune(textSrc)
-	sf.syntax, err = syntax.NewSyntax(runeSrc)
-	if err != nil {
-		return nil, fmt.Errorf("NewCompiler(): in create Syntax, err=\n\t%w", err)
+	_, ош = сам.руныКлассифицировать(исхГлавТекст)
+	if ош != nil {
+		return nil, мФорм.Errorf("НовКомпилятор(): при классификации рун главного модуля(%v), ош=\n\t%w", исхГлавИмя, ош)
 	}
-	return sf, nil
+	runeSrc := []rune(исхГлавТекст)
+	сам.syntax, ош = syntax.НовСинтаксис(runeSrc)
+	if ош != nil {
+		return nil, мФорм.Errorf("НовКомпилятор(): при создании Синтаксис, ош=\n\t%w", ош)
+	}
+	return сам, nil
 }
 
-// Run -- запускает компилятор в работу
-func (sf *Compiler) Run() error {
-	log.Printf("Compiler.Run()\n")
-	if err := sf.syntax.Run(); err != nil {
-		return fmt.Errorf("Compiler.Run(): in work main syntax, err=\n\t%w", err)
+// Пуск -- запускает компилятор в работу
+func (сам *Компилятор) Пуск() error {
+	мЛог.Printf("Компилятор.Пуск()\n")
+	if ош := сам.syntax.Пуск(); ош != nil {
+		return мФорм.Errorf("Компилятор.Пуск(): при работе Синтаксис в главном модуле, ош=\n\t%w", ош)
 	}
 	return nil
 }
 
 // Читает содержимое главного модуля
-func (sf *Compiler) readMainModule(srcName string) (string, error) {
-	binData, err := os.ReadFile(srcName)
-	if err != nil {
+func (sf *Компилятор) исхГлавЧитать(исхГлавИмя string) (string, error) {
+	бинДанные, ош := мОс.ReadFile(исхГлавИмя)
+	if ош != nil {
 		sf.printHelp()
-		return "", fmt.Errorf("Compiler.readMainModule(): in read srcMain(%v), err=\n\t%w", srcName, err)
+		return "", мФорм.Errorf("Компилятор.исхГлавЧитать(): при чтении главного модуля(%v), ош=\n\t%w", исхГлавИмя, ош)
 	}
-	return string(binData), nil
+	return string(бинДанные), nil
 }
 
 // Получает главный модуль программы из окружния для компиляции
-func (sf *Compiler) getMainModule() (string, error) {
-	log.Printf("Compiler.getMainModule()\n")
-	srcMain := os.Getenv("SRC_MAIN")
-	if srcMain == "" {
+func (sf *Компилятор) главМодульПолуч() (string, error) {
+	мЛог.Printf("Компилятор.главМодульПолуч()\n")
+	исхГлавИмя := мОс.Getenv("SRC_MAIN")
+	if исхГлавИмя == "" {
 		sf.printHelp()
-		return "", fmt.Errorf("Compiler.getMainModule(): env SRC_MAIN not set")
+		return "", мФорм.Errorf("Компилятор.главМодульПолуч(): env SRC_MAIN not set")
 	}
-	return srcMain, nil
+	return исхГлавИмя, nil
 }
 
 const (
-	help = `Оберон-У компилятор. 2023 г. BSD-2
+	справкаПоЗапуску = `Оберон-У компилятор. 2023 г. BSD-2
 
 	Для запуска компилятора необходимо определить переменную окружения:
-		export SRC_MAIN="./main.obu"
+		export SRC_MAIN="./main.ou"
 
 	Для подробной справки о языке смотрите тут:
 		http://p78git.ddns.net/svi/odeft
@@ -78,6 +83,11 @@ const (
 )
 
 // Печатает справку по использованию
-func (sf *Compiler) printHelp() {
-	log.Print(help)
+func (sf *Компилятор) printHelp() {
+	мЛог.Print(справкаПоЗапуску)
+}
+
+// Классифицирует руны исходника
+func (сам *Компилятор) руныКлассифицировать(текстИсх string) ([]src_rune.ИсхРуна, error) {
+	return nil, мФорм.Errorf("Компилятор.руныКлассифицировать(): доделать")
 }

internal/src_rune/src_rune.go

@@ -0,0 +1,47 @@
+// package src_rune -- руна исходника
+package src_rune
+
+import (
+	мФорм "fmt"
+	мЮникод "unicode"
+)
+
+const ( // Класс литеры
+	буква     = "буква"
+	цифра     = "цифра"
+	пробел    = "пробел"
+	точка     = "точка"
+	новСтрока = "\n"
+)
+
+// ИсхРуна -- руна исходника
+type ИсхРуна struct {
+	знач rune   // Хранимая руна
+	тип  string // Тип руны
+}
+
+// НовИсхРуна -- возвращае тновую руну исходника
+func НовИсхРуна(руна rune) (*ИсхРуна, error) {
+	сам := &ИсхРуна{
+		знач: руна,
+	}
+	if ош := сам.типУст(); ош != nil {
+		return nil, мФорм.Errorf("НовИсхРуна(): при проверке типа, ош=\n\t%w", ош)
+	}
+	return сам, nil
+}
+
+// Устанавливает тип руны
+func (сам *ИсхРуна) типУст() error {
+	if мЮникод.IsLetter(сам.знач) {
+		сам.тип = буква
+	}
+	if мЮникод.IsDigit(сам.знач) {
+		сам.тип = цифра
+	}
+	if сам.тип == "" {
+		сам.тип = "неизвестно"
+		return мФорм.Errorf("ИсхРуна.типУст(): неизвестный тип руны (%v)", сам.знач)
+	}
+	return nil
+}

internal/syntax/syntax.go

@@ -5,74 +5,47 @@ package syntax
 
 import (
 	"fmt"
-	"log"
-	"unicode"
+	лог "log"
 )
 
-const ( // Класс литеры
-	alpha   = "alpha" // Буква
-	digit   = "digit" // Цифра
-	space   = "space" // Пробел
-	dot     = "dot"   // Точка
-	newLine = "\n"    // Новая строка
-)
-
-// Syntax -- синтаксический потоковый анализатор
-type Syntax struct {
-	runeSrc []rune // Исходный набор рун для анализа
+// Синтаксис -- синтаксический потоковый анализатор
+type Синтаксис struct {
+	списокРун []rune // Исходный набор рун для анализа
+	рунаТекущ rune
 }
 
-// NewSyntax -- возвращает новый потоовый синтаксический анализатор
-func NewSyntax(runeSrc []rune) (*Syntax, error) {
-	log.Printf("NewSyntax()\n")
-	if runeSrc == nil {
-		return nil, fmt.Errorf("NewSyntax(): runeSrc==nil")
+// НовСинтаксис -- возвращает новый потоовый синтаксический анализатор
+func НовСинтаксис(списРун []rune) (*Синтаксис, error) {
+	лог.Printf("NewSyntax()\n")
+	if списРун == nil {
+		return nil, fmt.Errorf("НовСинтаксис(): runeSrc==nil")
 	}
-	sf := &Syntax{
-		runeSrc: runeSrc,
+	sf := &Синтаксис{
+		списокРун: списРун,
 	}
 	return sf, nil
 }
 
-// Run -- обрабатыает входящий поток данных
-func (sf *Syntax) Run() error {
-	log.Printf("Syntax.Run()\n")
+// Пуск -- обрабатыает входящий поток данных
+func (сам *Синтаксис) Пуск() error {
+	лог.Printf("Синтаксис.Пуск()\n")
 	i := 0
 	for {
-		if len(sf.runeSrc) == 0 {
+		if len(сам.списокРун) == 0 {
 			break
 		}
-		_rune := sf.runeSrc[0]
-		// что за тип руны?
-		switch class := sf.classifyRune(_rune); class {
-		case alpha: // какая-то буква, проверить наличие 'модуль'
-			sf.checkModuleBegin()
-		case digit:
-			// fmt.Printf("класс = цифра\n")
-		case space:
-		case dot:
-		case newLine:
-		default:
-			strRune := string(_rune)
-			fmt.Printf("%v\trune = %v\t", i, strRune)
-			fmt.Printf("класс = неизвестный\n")
-		}
 		i++
 	}
-	return fmt.Errorf("Syntax.Run(): доделать")
+	return fmt.Errorf("Синтаксис.Пуск(): доделать")
 }
 
 // Пытается вычислить начало модуля
-func (sf *Syntax)checkModuleBegin()bool{
-	
+func (сам *Синтаксис) checkModuleBegin() bool {
+	return false
 }
+
 // Классифицирует очередную руну из текста
-func (sf *Syntax) classifyRune(rune_ rune) string {
-	if unicode.IsLetter(rune_) {
-		return alpha
-	}
-	if unicode.IsDigit(rune_) {
-		return digit
-	}
+func (sf *Синтаксис) classifyRune(rune_ rune) string {
+
 	return ""
 }