ether-code 0.7.8 → 0.7.9

package/cli/ether.js

@@ -6,7 +6,7 @@ const http = require('http')
 const { EtherCompiler } = require('./compiler')
 const { Watcher } = require('./watcher')
 
-const VERSION = '0.7.8'
+const VERSION = '0.7.9'
 
 const COLORS = {
   reset: '\x1b[0m',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ether-code",
-  "version": "0.7.8",
+  "version": "0.7.9",
   "description": "Ether - Le langage intentionnel",
   "main": "cli/compiler.js",
   "bin": {
@@ -38,7 +38,7 @@
     "generators/",
     "lexer/",
     "i18n/",
-    "parsers/ether-parser.js",
+    "parsers/",
     "ether-compiler.js",
     "README.md",
     "LICENSE"

package/parsers/ether-parser-base.js

@@ -0,0 +1,361 @@
+const fs = require('fs')
+const { EtherLexer, Token, TokenType } = require('../lexer/ether-lexer')
+
+class EtherParserBase {
+  constructor(options = {}) {
+    this.tokens = []
+    this.pos = 0
+    this.currentIndent = 0
+    this.i18n = {}
+    this.reverseMaps = {}
+    this.targetLang = options.targetLang || 'auto'
+    this.i18nDir = options.i18nDir || './i18n'
+    
+    this.initCompoundTerms()
+  }
+
+  initCompoundTerms() {
+    this.compoundOperators = {
+      'strictement egal': '===',
+      'strictement égal': '===',
+      'strictement different': '!==',
+      'strictement différent': '!==',
+      'superieur ou egal': '>=',
+      'supérieur ou égal': '>=',
+      'inferieur ou egal': '<=',
+      'inférieur ou égal': '<=',
+      'coalescence nulle': '??',
+      'chainage optionnel': '?.',
+      'chaînage optionnel': '?.'
+    }
+    
+    this.compoundKeywords = {
+      'sinon si': 'else if',
+      'tant que': 'while',
+      'pour chaque': 'forEach',
+      'fonction asynchrone': 'async function',
+      'fonction async': 'async function',
+      'fonction generatrice': 'function*',
+      'fonction génératrice': 'function*',
+      'variable globale': 'var'
+    }
+  }
+
+  normalizeAccents(str) {
+    return str.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '')
+  }
+
+  loadI18n(files) {
+    for (const file of files) {
+      const lang = file.replace('i18n-', '').replace('.json', '')
+      const path = `${this.i18nDir}/${file}`
+      
+      try {
+        if (fs.existsSync(path)) {
+          this.i18n[lang] = JSON.parse(fs.readFileSync(path, 'utf-8'))
+          this.buildReverseMap(lang)
+        }
+      } catch (e) {}
+    }
+  }
+
+  buildReverseMap(lang) {
+    this.reverseMaps[lang] = {}
+    const data = this.i18n[lang]
+    
+    const processSection = (section, targetKey = lang) => {
+      if (!section || typeof section !== 'object') return
+      
+      for (const [key, translations] of Object.entries(section)) {
+        if (translations && typeof translations === 'object') {
+          if (translations.fr) {
+            const frTerms = Array.isArray(translations.fr) ? translations.fr : [translations.fr]
+            const target = translations[targetKey] || translations.css || translations.html || translations.js || translations.value
+            
+            for (const term of frTerms) {
+              if (typeof term === 'string') {
+                this.reverseMaps[lang][term.toLowerCase()] = target
+              }
+            }
+          }
+        }
+      }
+    }
+    
+    for (const [sectionName, sectionData] of Object.entries(data)) {
+      processSection(sectionData)
+    }
+  }
+
+  peek(offset = 0) {
+    const idx = this.pos + offset
+    return idx < this.tokens.length ? this.tokens[idx] : null
+  }
+
+  current() {
+    return this.tokens[this.pos] || null
+  }
+
+  advance() {
+    const token = this.tokens[this.pos]
+    this.pos++
+    return token
+  }
+
+  expect(type) {
+    const token = this.current()
+    if (!token || token.type !== type) {
+      throw new Error(`Attendu ${type}, reçu ${token ? token.type : 'EOF'}`)
+    }
+    return this.advance()
+  }
+
+  match(type) {
+    if (this.current() && this.current().type === type) {
+      return this.advance()
+    }
+    return null
+  }
+
+  check(type) {
+    const token = this.current()
+    return token && token.type === type
+  }
+
+  matchValue(value) {
+    const token = this.current()
+    if (!token || token.value === null || token.value === undefined) return null
+    const tokenVal = String(token.value).toLowerCase()
+    const valueLower = value.toLowerCase()
+    
+    if (tokenVal === valueLower) {
+      return this.advance()
+    }
+    
+    if (valueLower.includes(' ')) {
+      const parts = valueLower.split(' ')
+      if (tokenVal === parts[0]) {
+        const savedPos = this.pos
+        const tokens = [this.advance()]
+        let matched = true
+        
+        for (let i = 1; i < parts.length && matched; i++) {
+          const nextToken = this.current()
+          if (nextToken && String(nextToken.value).toLowerCase() === parts[i]) {
+            tokens.push(this.advance())
+          } else {
+            matched = false
+          }
+        }
+        
+        if (matched) {
+          return tokens[tokens.length - 1]
+        } else {
+          this.pos = savedPos
+        }
+      }
+    }
+    
+    return null
+  }
+
+  isAtEnd() {
+    return this.pos >= this.tokens.length || (this.current() && this.current().type === TokenType.EOF)
+  }
+
+  skipNewlines() {
+    while (this.match(TokenType.NEWLINE)) {}
+  }
+
+  skipWhitespace() {
+    while (this.match(TokenType.NEWLINE) || this.match(TokenType.INDENT) || this.match(TokenType.DEDENT)) {}
+  }
+
+  tryMatchCompoundOperator() {
+    const current = this.current()
+    if (!current || current.type !== TokenType.IDENTIFIER) return null
+    
+    const val1 = this.normalizeAccents(String(current.value))
+    const next = this.peek(1)
+    const next2 = this.peek(2)
+    
+    if (next && next.type === TokenType.IDENTIFIER) {
+      const val2 = this.normalizeAccents(String(next.value))
+      
+      if (next2 && next2.type === TokenType.IDENTIFIER) {
+        const val3 = this.normalizeAccents(String(next2.value))
+        const compound3 = `${val1} ${val2} ${val3}`
+        if (this.compoundOperators[compound3]) {
+          this.advance()
+          this.advance()
+          this.advance()
+          return this.compoundOperators[compound3]
+        }
+      }
+      
+      const compound2 = `${val1} ${val2}`
+      if (this.compoundOperators[compound2]) {
+        this.advance()
+        this.advance()
+        return this.compoundOperators[compound2]
+      }
+    }
+    
+    return null
+  }
+
+  tryMatchCompoundKeyword() {
+    const current = this.current()
+    if (!current || current.type !== TokenType.IDENTIFIER) return null
+    
+    const val1 = this.normalizeAccents(String(current.value))
+    const next = this.peek(1)
+    
+    if (next && next.type === TokenType.IDENTIFIER) {
+      const val2 = this.normalizeAccents(String(next.value))
+      const compound2 = `${val1} ${val2}`
+      if (this.compoundKeywords[compound2]) {
+        this.advance()
+        this.advance()
+        return this.compoundKeywords[compound2]
+      }
+    }
+    
+    return null
+  }
+
+  tokenize(source) {
+    const lexer = new EtherLexer(source)
+    this.tokens = lexer.tokenize()
+    this.pos = 0
+    return this.tokens
+  }
+
+  parseBlock(lang) {
+    const body = []
+    
+    const hasBrace = this.match(TokenType.LBRACE)
+    this.skipNewlines()
+    
+    if (hasBrace) {
+      this.match(TokenType.INDENT)
+    }
+    
+    if (hasBrace || this.match(TokenType.INDENT)) {
+      while (!this.isAtEnd()) {
+        this.skipNewlines()
+        
+        const current = this.current()
+        
+        if (current && current.type === TokenType.DEDENT) {
+          this.advance()
+          if (hasBrace) {
+            this.skipNewlines()
+            this.match(TokenType.RBRACE)
+          }
+          break
+        }
+        
+        if (hasBrace && current && current.type === TokenType.RBRACE) {
+          this.advance()
+          break
+        }
+        
+        if (current && current.type === TokenType.COMMA) {
+          break
+        }
+        
+        if (current && current.type === TokenType.RPAREN) {
+          break
+        }
+        
+        if (current && (current.type === TokenType.INDENT || current.type === TokenType.NEWLINE)) {
+          this.advance()
+          continue
+        }
+        
+        const statement = this.parseStatement(lang)
+        if (statement && statement.expression?.value !== null) {
+          body.push(statement)
+        } else if (statement && statement.type !== 'ExpressionStatement') {
+          body.push(statement)
+        }
+        
+        this.skipNewlines()
+      }
+    }
+    
+    return {
+      type: 'BlockStatement',
+      body: body
+    }
+  }
+
+  parseParameter(lang) {
+    const nameToken = this.current()
+    if (!nameToken || nameToken.type !== TokenType.IDENTIFIER) {
+      return null
+    }
+    const name = nameToken.value
+    this.advance()
+    
+    let typeAnnotation = null
+    if (this.match(TokenType.COLON)) {
+      typeAnnotation = this.parseType(lang)
+    }
+    
+    let defaultValue = null
+    if (this.match(TokenType.EQUALS)) {
+      defaultValue = this.parseExpression(lang)
+    }
+    
+    return {
+      type: 'Parameter',
+      name: name,
+      typeAnnotation: typeAnnotation,
+      default: defaultValue
+    }
+  }
+
+  parseType(lang) {
+    const token = this.current()
+    if (!token || token.type !== TokenType.IDENTIFIER) {
+      return null
+    }
+    
+    const typeName = token.value
+    this.advance()
+    
+    let typeArgs = []
+    if (this.match(TokenType.LT)) {
+      while (!this.isAtEnd() && !this.match(TokenType.GT)) {
+        const arg = this.parseType(lang)
+        if (arg) typeArgs.push(arg)
+        this.match(TokenType.COMMA)
+      }
+    }
+    
+    let isArray = false
+    if (this.match(TokenType.LBRACKET)) {
+      this.match(TokenType.RBRACKET)
+      isArray = true
+    }
+    
+    return {
+      type: 'TypeAnnotation',
+      name: typeName,
+      typeArguments: typeArgs,
+      isArray: isArray
+    }
+  }
+
+  parseStatement(lang) {
+    throw new Error('parseStatement must be implemented by subclass')
+  }
+
+  parseExpression(lang) {
+    throw new Error('parseExpression must be implemented by subclass')
+  }
+}
+
+module.exports = { EtherParserBase, TokenType }