ether-code 0.8.3 → 0.8.5

package/cli/ether.js

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

package/generators/php-generator.js

@@ -101,6 +101,8 @@ class PHPGenerator {
 
     const generators = {
       'Program': () => this.generateProgram(node),
+      'DeclareStatement': () => this.generateDeclareStatement(node),
+      'NamespaceDeclaration': () => this.generateNamespaceDeclaration(node),
       'FunctionDeclaration': () => this.generateFunctionDeclaration(node),
       'ClassDeclaration': () => this.generateClassDeclaration(node),
       'InterfaceDeclaration': () => this.generateInterfaceDeclaration(node),
@@ -110,6 +112,7 @@ class PHPGenerator {
       'PropertyDeclaration': () => this.generatePropertyDeclaration(node),
       'VariableDeclaration': () => this.generateVariableDeclaration(node),
       'ConstantDeclaration': () => this.generateConstantDeclaration(node),
+      'DefineDeclaration': () => this.generateDefineDeclaration(node),
       'IfStatement': () => this.generateIfStatement(node),
       'ForStatement': () => this.generateForStatement(node),
       'ForEachStatement': () => this.generateForEachStatement(node),
@@ -176,6 +179,33 @@ class PHPGenerator {
     }
   }
 
+  generateDeclareStatement(node) {
+    const directives = (node.directives || []).map(d => {
+      const name = this.safeString(d.name)
+      const value = this.generateNode(d.value)
+      return `${name}=${value}`
+    }).join(', ')
+    
+    this.writeLine(`declare(${directives});`)
+    this.writeLine('')
+  }
+
+  generateNamespaceDeclaration(node) {
+    const name = this.safeString(node.name)
+    this.writeLine(`namespace ${name};`)
+    this.writeLine('')
+    
+    if (node.body) {
+      this.generateNode(node.body)
+    }
+  }
+
+  generateDefineDeclaration(node) {
+    const name = this.safeString(node.name)
+    const value = this.generateNode(node.value)
+    this.writeLine(`define('${name}', ${value});`)
+  }
+
   generateFunctionDeclaration(node) {
     const name = this.safeString(node.name || node.id?.name || 'anonymous')
     const translatedName = this.translate(name)
@@ -465,7 +495,7 @@ class PHPGenerator {
   generateVariableDeclaration(node) {
     for (const decl of node.declarations || [node]) {
       const name = this.safeString(decl.name || decl.id?.name || decl.id)
-      const varName = '$' + this.translate(name)
+      const varName = '$' + name
       
       if (decl.init !== undefined) {
         const value = this.generateNode(decl.init)
@@ -489,7 +519,7 @@ class PHPGenerator {
   }
 
   generateIfStatement(node) {
-    const test = this.generateNode(node.test)
+    const test = this.generateNode(node.test || node.condition)
     this.writeLine(`if (${test}) {`)
     this.indent++
     this.generateNode(node.consequent)
@@ -497,7 +527,7 @@ class PHPGenerator {
     
     if (node.alternate) {
       if (node.alternate.type === 'IfStatement') {
-        this.write('} else')
+        this.write('} else ')
         this.generateIfStatement({ ...node.alternate, isElseIf: true })
       } else {
         this.writeLine('} else {')
@@ -536,7 +566,7 @@ class PHPGenerator {
   }
 
   generateWhileStatement(node) {
-    const test = this.generateNode(node.test)
+    const test = this.generateNode(node.test || node.condition)
     this.writeLine(`while (${test}) {`)
     this.indent++
     this.generateNode(node.body)
@@ -549,7 +579,7 @@ class PHPGenerator {
     this.indent++
     this.generateNode(node.body)
     this.indent--
-    const test = this.generateNode(node.test)
+    const test = this.generateNode(node.test || node.condition)
     this.writeLine(`} while (${test});`)
   }
 
@@ -640,7 +670,8 @@ class PHPGenerator {
   }
 
   generateEchoStatement(node) {
-    const args = (node.arguments || [node.argument]).filter(Boolean).map(a => this.generateNode(a)).join(', ')
+    const exprs = node.expressions || node.arguments || [node.argument]
+    const args = exprs.filter(Boolean).map(a => this.generateNode(a)).join(', ')
     this.writeLine(`echo ${args};`)
   }
 
@@ -656,10 +687,19 @@ class PHPGenerator {
   }
 
   generateUseStatement(node) {
-    const name = this.safeString(node.name || node.source)
-    const alias = node.alias ? ' as ' + node.alias : ''
-    const type = node.type === 'function' ? 'function ' : (node.type === 'const' ? 'const ' : '')
-    this.writeLine(`use ${type}${name}${alias};`)
+    const typePrefix = node.useType === 'function' ? 'function ' : (node.useType === 'const' ? 'const ' : '')
+    
+    if (node.imports && node.imports.length > 0) {
+      for (const imp of node.imports) {
+        const path = this.safeString(imp.path)
+        const alias = imp.alias ? ' as ' + imp.alias : ''
+        this.writeLine(`use ${typePrefix}${path}${alias};`)
+      }
+    } else {
+      const name = this.safeString(node.name || node.source)
+      const alias = node.alias ? ' as ' + node.alias : ''
+      this.writeLine(`use ${typePrefix}${name}${alias};`)
+    }
   }
 
   generateIncludeStatement(node) {
@@ -772,21 +812,21 @@ class PHPGenerator {
   }
 
   generateUnaryExpression(node) {
-    const argument = this.generateNode(node.argument)
+    const argument = this.generateNode(node.argument || node.operand)
     let op = node.operator
     if (op === 'non' || op === 'not') op = '!'
     
-    if (node.prefix) {
+    if (node.prefix !== false) {
       return `${op}${argument}`
     }
     return `${argument}${op}`
   }
 
   generateUpdateExpression(node) {
-    const argument = this.generateNode(node.argument)
+    const argument = this.generateNode(node.argument || node.operand)
     const op = node.operator
     
-    if (node.prefix) {
+    if (node.prefix !== false) {
       return `${op}${argument}`
     }
     return `${argument}${op}`
@@ -878,43 +918,41 @@ class PHPGenerator {
     if (!node) return '$var'
     
     const name = this.safeString(node.name || node.id?.name || node)
-    const translated = this.translate(name)
-    const translatedStr = String(translated)
+    const nameStr = String(name)
     
-    if (translatedStr.startsWith('$')) return translatedStr
-    return '$' + translatedStr
+    if (nameStr.startsWith('$')) return nameStr
+    return '$' + nameStr
   }
 
   generateIdentifier(node) {
     if (!node) return '$var'
     
     const name = this.safeString(node.name || node.id?.name || node)
-    const translated = this.translate(name)
-    const translatedStr = String(translated)
+    const nameStr = String(name)
     
-    if (translatedStr.startsWith('$')) return translatedStr
+    if (nameStr.startsWith('$')) return nameStr
     
     const keywords = [
       'true', 'false', 'null', 
       'self', 'parent', 'static',
       'this', '$this'
     ]
-    if (keywords.includes(translatedStr.toLowerCase())) {
-      if (translatedStr.toLowerCase() === 'this') return '$this'
-      return translatedStr
+    if (keywords.includes(nameStr.toLowerCase())) {
+      if (nameStr.toLowerCase() === 'this') return '$this'
+      return nameStr
     }
     
-    if (/^[A-Z]/.test(translatedStr)) return translatedStr
+    if (/^[A-Z]/.test(nameStr)) return nameStr
     
-    if (translatedStr.includes('(') || translatedStr.includes('::')) return translatedStr
+    if (nameStr.includes('(') || nameStr.includes('::')) return nameStr
     
     const superglobals = ['_GET', '_POST', '_SERVER', '_SESSION', '_COOKIE', '_FILES', '_REQUEST', '_ENV', 'GLOBALS']
-    const upper = translatedStr.toUpperCase()
-    if (superglobals.includes(translatedStr) || superglobals.includes(upper)) {
+    const upper = nameStr.toUpperCase()
+    if (superglobals.includes(nameStr) || superglobals.includes(upper)) {
       return '$' + upper
     }
     
-    return '$' + translatedStr
+    return '$' + nameStr
   }
 
   generateLiteral(node) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ether-code",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "description": "Ether - Le langage intentionnel",
   "main": "cli/compiler.js",
   "bin": {

package/parsers/ether-parser-php.js

@@ -278,6 +278,10 @@ class EtherParserPHP extends EtherParserBase {
 
     const value = token.value != null ? this.normalizeAccents(String(token.value).toLowerCase()) : ''
 
+    if (this.isDeclare(value)) {
+      return this.parseDeclare(lang)
+    }
+
     if (this.isNamespace(value)) {
       return this.parseNamespace(lang)
     }
@@ -371,7 +375,17 @@ class EtherParserPHP extends EtherParserBase {
   }
 
   isNamespace(value) {
-    return ['namespace', 'espace de noms'].includes(value)
+    if (value === 'namespace') return true
+    if (value === 'espace') {
+      const next1 = this.peek(1)
+      const next2 = this.peek(2)
+      if (next1 && next2) {
+        const val1 = this.normalizeAccents(String(next1.value).toLowerCase())
+        const val2 = this.normalizeAccents(String(next2.value).toLowerCase())
+        if (val1 === 'de' && val2 === 'noms') return true
+      }
+    }
+    return false
   }
 
   isUse(value) {
@@ -469,8 +483,54 @@ class EtherParserPHP extends EtherParserBase {
     return value === 'match'
   }
 
-  parseNamespace(lang) {
+  isDeclare(value) {
+    return ['declare', 'declarer', 'déclarer'].includes(value)
+  }
+
+  parseDeclare(lang) {
     this.advance()
+    
+    const directives = []
+    
+    if (this.match(TokenType.LPAREN)) {
+      do {
+        const nameToken = this.current()
+        const name = nameToken ? this.safeStr(nameToken.value) : ''
+        this.advance()
+        
+        this.match(TokenType.EQUALS)
+        
+        const value = this.parseExpression(lang)
+        directives.push({ name, value })
+      } while (this.match(TokenType.COMMA))
+      
+      this.match(TokenType.RPAREN)
+    } else {
+      const nameToken = this.current()
+      const name = nameToken ? this.safeStr(nameToken.value) : ''
+      this.advance()
+      
+      this.match(TokenType.EQUALS)
+      
+      const value = this.parseExpression(lang)
+      directives.push({ name, value })
+    }
+    
+    return {
+      type: 'DeclareStatement',
+      directives: directives
+    }
+  }
+
+  parseNamespace(lang) {
+    const first = this.advance()
+    const firstVal = this.normalizeAccents(String(first.value).toLowerCase())
+    
+    if (firstVal === 'espace') {
+      this.advance()
+      this.advance()
+    }
+    
     const name = this.parseNamespacePath(lang)
     this.skipNewlines()
     
@@ -1098,6 +1158,7 @@ class EtherParserPHP extends EtherParserBase {
     let variadic = false
     let byReference = false
     let defaultValue = null
+    let name = null
 
     const val = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
     if (this.phpVisibility.includes(val)) {
@@ -1111,16 +1172,6 @@ class EtherParserPHP extends EtherParserBase {
       this.advance()
     }
 
-    const currentType = this.current()
-    if (currentType && currentType.type === TokenType.IDENTIFIER) {
-      const typeLower = this.normalizeAccents(String(currentType.value).toLowerCase())
-      if (this.phpTypes[typeLower] || typeLower[0] === typeLower[0].toUpperCase()) {
-        if (!this.peek(1) || this.peek(1).type !== TokenType.EQUALS) {
-          typeHint = this.parseTypeHint(lang)
-        }
-      }
-    }
-
     if (this.match(TokenType.SPREAD) || this.matchValue('...')) {
       variadic = true
     }
@@ -1129,14 +1180,34 @@ class EtherParserPHP extends EtherParserBase {
       byReference = true
     }
 
-    const nameToken = this.current()
-    if (!nameToken) return null
+    const currentToken = this.current()
+    if (!currentToken) return null
+
+    const nextToken = this.peek(1)
     
-    let name = this.safeStr(nameToken.value)
-    if (name.startsWith('$')) {
-      name = name.substring(1)
+    if (nextToken && nextToken.type === TokenType.COLON) {
+      name = this.safeStr(currentToken.value)
+      if (name.startsWith('$')) name = name.substring(1)
+      this.advance()
+      this.advance()
+      typeHint = this.parseTypeHint(lang)
+    } else {
+      const typeLower = this.normalizeAccents(String(currentToken.value).toLowerCase())
+      if (this.phpTypes[typeLower] || /^[A-Z]/.test(currentToken.value)) {
+        typeHint = this.parseTypeHint(lang)
+      }
+      
+      const nameToken = this.current()
+      if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
+        name = this.safeStr(nameToken.value)
+        if (name.startsWith('$')) name = name.substring(1)
+        this.advance()
+      }
+    }
+
+    if (!name) {
+      name = 'param'
     }
-    this.advance()
 
     if (this.match(TokenType.EQUALS)) {
       defaultValue = this.parseExpression(lang)
@@ -1252,9 +1323,10 @@ class EtherParserPHP extends EtherParserBase {
       condition = this.parseExpression(lang)
       this.match(TokenType.RPAREN)
     } else {
-      condition = this.parseExpression(lang)
+      condition = this.parseConditionUntilColon(lang)
     }
 
+    this.match(TokenType.COLON)
     this.skipNewlines()
     const consequent = this.parseBlock(lang)
 
@@ -1262,31 +1334,64 @@ class EtherParserPHP extends EtherParserBase {
     this.skipNewlines()
     
     const elseVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
-    if (elseVal === 'sinon si' || elseVal === 'elseif') {
-      this.advance()
-      alternate = this.parseConditional(lang)
-      alternate.type = 'ElseIfStatement'
-    } else if (elseVal === 'sinon' || elseVal === 'else') {
+    if (elseVal === 'sinon') {
       this.advance()
       
       const nextVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
       if (nextVal === 'si' || nextVal === 'if') {
         alternate = this.parseConditional(lang)
-        alternate.type = 'ElseIfStatement'
+        alternate.type = 'IfStatement'
       } else {
+        this.match(TokenType.COLON)
         this.skipNewlines()
         alternate = this.parseBlock(lang)
       }
+    } else if (elseVal === 'else') {
+      this.advance()
+      this.match(TokenType.COLON)
+      this.skipNewlines()
+      alternate = this.parseBlock(lang)
     }
 
     return {
       type: 'IfStatement',
-      condition: condition,
+      test: condition,
       consequent: consequent,
       alternate: alternate
     }
   }
 
+  parseConditionUntilColon(lang) {
+    const startPos = this.pos
+    let depth = 0
+    
+    while (!this.isAtEnd()) {
+      const token = this.current()
+      if (!token) break
+      
+      if (token.type === TokenType.LPAREN) depth++
+      if (token.type === TokenType.RPAREN) depth--
+      
+      if (depth === 0 && token.type === TokenType.COLON) {
+        break
+      }
+      if (depth === 0 && token.type === TokenType.NEWLINE) {
+        break
+      }
+      
+      this.advance()
+    }
+    
+    const endPos = this.pos
+    this.pos = startPos
+    
+    if (endPos > startPos) {
+      return this.parseExpression(lang)
+    }
+    
+    return { type: 'Literal', value: true }
+  }
+
   parseLoop(lang) {
     const token = this.current()
     const value = this.normalizeAccents(String(token.value).toLowerCase())
@@ -1325,7 +1430,7 @@ class EtherParserPHP extends EtherParserBase {
 
   parseFor(lang) {
     this.advance()
-
+    
     let init = null
     let test = null
     let update = null
@@ -1345,8 +1450,23 @@ class EtherParserPHP extends EtherParserBase {
         update = this.parseExpression(lang)
       }
       this.match(TokenType.RPAREN)
+    } else {
+      if (!this.check(TokenType.SEMICOLON) && !this.check(TokenType.COLON)) {
+        init = this.parseExpression(lang)
+      }
+      this.match(TokenType.SEMICOLON)
+      
+      if (!this.check(TokenType.SEMICOLON) && !this.check(TokenType.COLON)) {
+        test = this.parseExpression(lang)
+      }
+      this.match(TokenType.SEMICOLON)
+      
+      if (!this.check(TokenType.COLON) && !this.check(TokenType.NEWLINE)) {
+        update = this.parseExpression(lang)
+      }
     }
 
+    this.match(TokenType.COLON)
     this.skipNewlines()
     const body = this.parseBlock(lang)
 
@@ -1390,7 +1510,7 @@ class EtherParserPHP extends EtherParserBase {
         }
         
         const valueVar = this.current()
-        let value = this.safeStr(valueVar ? valueVar.value : 'value')
+        value = this.safeStr(valueVar ? valueVar.value : 'value')
         if (value.startsWith('$')) value = value.substring(1)
         this.advance()
       } else {
@@ -1398,8 +1518,44 @@ class EtherParserPHP extends EtherParserBase {
       }
 
       this.match(TokenType.RPAREN)
+    } else {
+      const arrayToken = this.current()
+      if (arrayToken) {
+        array = { type: 'Identifier', name: this.safeStr(arrayToken.value) }
+        this.advance()
+      }
+      
+      const asVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+      if (asVal === 'comme' || asVal === 'as') {
+        this.advance()
+      }
+
+      if (this.match(TokenType.AMPERSAND)) {
+        byRef = true
+      }
+
+      const firstVar = this.current()
+      let firstName = this.safeStr(firstVar ? firstVar.value : 'item')
+      if (firstName.startsWith('$')) firstName = firstName.substring(1)
+      this.advance()
+
+      if (this.match(TokenType.DOUBLE_ARROW) || this.matchValue('=>')) {
+        key = firstName
+        
+        if (this.match(TokenType.AMPERSAND)) {
+          byRef = true
+        }
+        
+        const valueVar = this.current()
+        value = this.safeStr(valueVar ? valueVar.value : 'value')
+        if (value.startsWith('$')) value = value.substring(1)
+        this.advance()
+      } else {
+        value = firstName
+      }
     }
 
+    this.match(TokenType.COLON)
     this.skipNewlines()
     const body = this.parseBlock(lang)
 
@@ -1419,15 +1575,16 @@ class EtherParserPHP extends EtherParserBase {
       condition = this.parseExpression(lang)
       this.match(TokenType.RPAREN)
     } else {
-      condition = this.parseExpression(lang)
+      condition = this.parseConditionUntilColon(lang)
     }
 
+    this.match(TokenType.COLON)
     this.skipNewlines()
     const body = this.parseBlock(lang)
 
     return {
       type: 'WhileStatement',
-      condition: condition,
+      test: condition,
       body: body
     }
   }