kokoscript 1.0.0

package/src/cli/repl.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+// KokoScript REPL (Read-Eval-Print Loop)
+
+const readline = require('readline');
+const { compile } = require('../compiler');
+
+function startRepl() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: 'KokoScript> '
+  });
+  
+  console.log('KokoScript REPL v1.0.0');
+  console.log('終了するには .exit と入力してください');
+  console.log('');
+  
+  let buffer = '';
+  let context = {};
+  
+  rl.prompt();
+  
+  rl.on('line', (line) => {
+    line = line.trim();
+    
+    if (line === '.exit') {
+      console.log('さようなら！');
+      rl.close();
+      return;
+    }
+    
+    if (line === '.clear') {
+      buffer = '';
+      context = {};
+      console.log('バッファとコンテキストをクリアしました');
+      rl.prompt();
+      return;
+    }
+    
+    if (line === '.help') {
+      console.log('コマンド:');
+      console.log('  .exit  - REPLを終了');
+      console.log('  .clear - バッファとコンテキストをクリア');
+      console.log('  .help  - このヘルプを表示');
+      rl.prompt();
+      return;
+    }
+    
+    if (line === '') {
+      rl.prompt();
+      return;
+    }
+    
+    buffer += line + '\n';
+    
+    // 「終わり」で終わる場合、または単一文の場合は実行
+    if (line.includes('終わり') || 
+        (!line.includes('ならば') && !line.includes('繰り返す') && !line.includes('定義する'))) {
+      
+      const result = compile(buffer);
+      
+      if (result.success) {
+        try {
+          // コンテキストを保持しながら実行
+          const wrappedCode = `
+            (function() {
+              with (context) {
+                ${result.code}
+              }
+            })();
+          `;
+          eval(wrappedCode);
+        } catch (error) {
+          console.error('実行エラー:', error.message);
+        }
+      } else {
+        console.error('コンパイルエラー:', result.error);
+      }
+      
+      buffer = '';
+    }
+    
+    rl.prompt();
+  }).on('close', () => {
+    console.log('\nまた起動してね。');
+    process.exit(0);
+  });
+}
+
+if (require.main === module) {
+  startRepl();
+}
+
+module.exports = { startRepl };

package/src/compiler/codegen.js

@@ -0,0 +1,188 @@
+// コードジェネレーター（JavaScriptへの変換）
+
+class CodeGenerator {
+  constructor(ast) {
+    this.ast = ast;
+    this.output = '';
+    this.indent = 0;
+  }
+
+  generate() {
+    this.visitProgram(this.ast);
+    return this.output;
+  }
+
+  visitProgram(node) {
+    for (const statement of node.statements) {
+      this.visitStatement(statement);
+    }
+  }
+
+  visitStatement(node) {
+    switch (node.type) {
+      case 'VariableDeclaration':
+        this.visitVariableDeclaration(node);
+        break;
+      case 'IfStatement':
+        this.visitIfStatement(node);
+        break;
+      case 'RepeatStatement':
+        this.visitRepeatStatement(node);
+        break;
+      case 'FunctionDeclaration':
+        this.visitFunctionDeclaration(node);
+        break;
+      case 'CallExpression':
+        this.visitCallExpression(node);
+        this.emit(';\n');
+        break;
+      case 'Assignment':
+        this.visitAssignment(node);
+        break;
+      case 'ReturnStatement':
+        this.visitReturnStatement(node);
+        break;
+      case 'DisplayStatement':
+        this.visitDisplayStatement(node);
+        break;
+    }
+  }
+
+  visitVariableDeclaration(node) {
+    this.emit('let ');
+    this.emit(node.name);
+    this.emit(' = ');
+    this.visitExpression(node.value);
+    this.emit(';\n');
+  }
+
+  visitIfStatement(node) {
+    this.emit('if (');
+    this.visitExpression(node.condition);
+    this.emit(') {\n');
+    
+    this.indent++;
+    for (const stmt of node.consequent) {
+      this.emitIndent();
+      this.visitStatement(stmt);
+    }
+    this.indent--;
+    
+    if (node.alternate && node.alternate.length > 0) {
+      this.emitIndent();
+      this.emit('} else {\n');
+      this.indent++;
+      for (const stmt of node.alternate) {
+        this.emitIndent();
+        this.visitStatement(stmt);
+      }
+      this.indent--;
+    }
+    
+    this.emitIndent();
+    this.emit('}\n');
+  }
+
+  visitRepeatStatement(node) {
+    this.emit('for (let _i = 0; _i < ');
+    this.emit(node.count.toString());
+    this.emit('; _i++) {\n');
+    
+    this.indent++;
+    for (const stmt of node.body) {
+      this.emitIndent();
+      this.visitStatement(stmt);
+    }
+    this.indent--;
+    
+    this.emitIndent();
+    this.emit('}\n');
+  }
+
+  visitFunctionDeclaration(node) {
+    this.emit('function ');
+    this.emit(node.name);
+    this.emit('(');
+    this.emit(node.params.join(', '));
+    this.emit(') {\n');
+    
+    this.indent++;
+    for (const stmt of node.body) {
+      this.emitIndent();
+      this.visitStatement(stmt);
+    }
+    this.indent--;
+    
+    this.emitIndent();
+    this.emit('}\n');
+  }
+
+  visitCallExpression(node) {
+    this.emit(node.name);
+    this.emit('(');
+    for (let i = 0; i < node.args.length; i++) {
+      this.visitExpression(node.args[i]);
+      if (i < node.args.length - 1) {
+        this.emit(', ');
+      }
+    }
+    this.emit(')');
+  }
+
+  visitAssignment(node) {
+    this.emit(node.name);
+    this.emit(' = ');
+    this.visitExpression(node.value);
+    this.emit(';\n');
+  }
+
+  visitReturnStatement(node) {
+    this.emit('return ');
+    this.visitExpression(node.value);
+    this.emit(';\n');
+  }
+
+  visitDisplayStatement(node) {
+    this.emit('console.log(');
+    for (let i = 0; i < node.expressions.length; i++) {
+      this.visitExpression(node.expressions[i]);
+      if (i < node.expressions.length - 1) {
+        this.emit(' + ');
+      }
+    }
+    this.emit(');\n');
+  }
+
+  visitExpression(node) {
+    switch (node.type) {
+      case 'Literal':
+        if (typeof node.value === 'string') {
+          this.emit(`"${node.value}"`);
+        } else {
+          this.emit(String(node.value));
+        }
+        break;
+      case 'Identifier':
+        this.emit(node.name);
+        break;
+      case 'BinaryExpression':
+        this.visitExpression(node.left);
+        this.emit(' ' + node.operator + ' ');
+        this.visitExpression(node.right);
+        break;
+      case 'CallExpression':
+        this.visitCallExpression(node);
+        break;
+    }
+  }
+
+  emit(code) {
+    this.output += code;
+  }
+
+  emitIndent() {
+    this.output += '  '.repeat(this.indent);
+  }
+}
+
+module.exports = { CodeGenerator };

package/src/compiler/index.js

@@ -0,0 +1,27 @@
+const { Lexer } = require('./lexer');
+const { Parser } = require('./parser');
+const { CodeGenerator } = require('./codegen');
+
+function compile(source) {
+  try {
+    const lexer = new Lexer(source);
+    const tokens = lexer.tokenize();
+
+    const parser = new Parser(tokens);
+    const ast = parser.parse();
+
+    const codegen = new CodeGenerator(ast);
+    const jsCode = codegen.generate();
+
+    return { success: true, code: jsCode, ast };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+module.exports = {
+  compile,
+  Lexer,
+  Parser,
+  CodeGenerator
+};

package/src/compiler/lexer.js

@@ -0,0 +1,306 @@
+// レキサー（字句解析器） - 句読点ベース
+
+class Token {
+  constructor(type, value, line, col) {
+    this.type = type;
+    this.value = value;
+    this.line = line;
+    this.col = col;
+  }
+}
+
+const TOKEN_TYPES = {
+  KEYWORD: 'KEYWORD',
+  IDENTIFIER: 'IDENTIFIER',
+  NUMBER: 'NUMBER',
+  STRING: 'STRING',
+  OPERATOR: 'OPERATOR',
+  COMMA: 'COMMA',      // 、
+  PERIOD: 'PERIOD',    // 。
+  NEWLINE: 'NEWLINE',
+  EOF: 'EOF'
+};
+
+// キーワード（句読点の前後で区切られる）
+const KEYWORDS = new Set([
+  '変数', 'は', 'を', 'に', 'が', 'と', 'で', 'の', 'から',
+  'もし', 'ならば', 'そうでなければ', '終わり',
+  '回', '繰り返す', '抜ける', '続ける',
+  '関数', '返す', '呼ぶ',
+  'より', '大きい', '小さい', '等しい', '以上', '以下',
+  '表示', '渡す', '足す', '引く', '掛ける', '割る',
+  '真', '偽', '空'
+]);
+
+class Lexer {
+  constructor(source) {
+    this.source = source;
+    this.pos = 0;
+    this.line = 1;
+    this.col = 1;
+    this.tokens = [];
+  }
+
+  tokenize() {
+    while (this.pos < this.source.length) {
+      this.skipWhitespace();
+      
+      if (this.pos >= this.source.length) break;
+
+      const char = this.source[this.pos];
+
+      // 改行
+      if (char === '\n') {
+        this.advance();
+        this.line++;
+        this.col = 1;
+        continue;
+      }
+
+      // 読点（、）- キーワードの区切り
+      if (char === '、' || char === '，') {
+        this.tokens.push(new Token(TOKEN_TYPES.COMMA, '、', this.line, this.col));
+        this.advance();
+        continue;
+      }
+
+      // 句点（。）- 文の終わり
+      if (char === '。' || char === '．') {
+        this.tokens.push(new Token(TOKEN_TYPES.PERIOD, '。', this.line, this.col));
+        this.advance();
+        continue;
+      }
+
+      // コメント
+      if (char === '#' || (char === '/' && this.source[this.pos + 1] === '/')) {
+        this.skipComment();
+        continue;
+      }
+
+      // 文字列
+      if (char === '「' || char === '"' || char === "'") {
+        this.tokens.push(this.readString());
+        continue;
+      }
+
+      // 数値
+      if (this.isDigit(char)) {
+        this.tokens.push(this.readNumber());
+        continue;
+      }
+
+      // 演算子
+      if (this.isOperator(char)) {
+        this.tokens.push(this.readOperator());
+        continue;
+      }
+
+      // 識別子またはキーワード
+      if (this.isIdentifierStart(char)) {
+        this.tokens.push(this.readIdentifier());
+        continue;
+      }
+
+      // 不明な文字はスキップ
+      this.advance();
+    }
+
+    this.tokens.push(new Token(TOKEN_TYPES.EOF, null, this.line, this.col));
+    return this.tokens;
+  }
+
+  skipWhitespace() {
+    while (this.pos < this.source.length) {
+      const char = this.source[this.pos];
+      if (char === ' ' || char === '\t' || char === '\r') {
+        this.advance();
+      } else {
+        break;
+      }
+    }
+  }
+
+  skipComment() {
+    while (this.pos < this.source.length && this.source[this.pos] !== '\n') {
+      this.advance();
+    }
+  }
+
+  readString() {
+    const startLine = this.line;
+    const startCol = this.col;
+    const startChar = this.source[this.pos];
+    let endChar = startChar === '「' ? '」' : startChar;
+    
+    this.advance();
+
+    let value = '';
+    while (this.pos < this.source.length && this.source[this.pos] !== endChar) {
+      if (this.source[this.pos] === '\\' && this.pos + 1 < this.source.length) {
+        this.advance();
+        const escapeChar = this.source[this.pos];
+        switch (escapeChar) {
+          case 'n': value += '\n'; break;
+          case 't': value += '\t'; break;
+          case '\\': value += '\\'; break;
+          default: value += escapeChar;
+        }
+        this.advance();
+      } else {
+        value += this.source[this.pos];
+        this.advance();
+      }
+    }
+
+    if (this.pos < this.source.length) {
+      this.advance();
+    }
+
+    return new Token(TOKEN_TYPES.STRING, value, startLine, startCol);
+  }
+
+  readNumber() {
+    const startLine = this.line;
+    const startCol = this.col;
+    let value = '';
+    let hasDot = false;
+
+    while (this.pos < this.source.length) {
+      const char = this.source[this.pos];
+      if (this.isDigit(char)) {
+        value += char;
+        this.advance();
+      } else if (char === '.' && !hasDot) {
+        hasDot = true;
+        value += char;
+        this.advance();
+      } else {
+        break;
+      }
+    }
+
+    return new Token(TOKEN_TYPES.NUMBER, parseFloat(value), startLine, startCol);
+  }
+
+  readIdentifier() {
+    const startLine = this.line;
+    const startCol = this.col;
+    let value = '';
+
+    // 一文字ずつ読みながら、キーワードをチェック
+    while (this.pos < this.source.length) {
+      const char = this.source[this.pos];
+      
+      // 句読点で止まる
+      if (char === '、' || char === '，' || char === '。' || char === '．') {
+        break;
+      }
+      
+      // スペースで止まる
+      if (char === ' ' || char === '\t' || char === '\r' || char === '\n') {
+        break;
+      }
+      
+      // 数字で止まる（識別子と数字は別々にトークン化）
+      if (this.isDigit(char)) {
+        break;
+      }
+      
+      // 演算子で止まる
+      if (this.isOperator(char)) {
+        break;
+      }
+      
+      // 文字列開始で止まる
+      if (char === '「' || char === '"' || char === "'") {
+        break;
+      }
+      
+      if (!this.isIdentifierChar(char)) {
+        break;
+      }
+      
+      value += char;
+      this.advance();
+      
+      // 読んだ部分の末尾がキーワードかチェック
+      // ただし、もっと長く読むとより長いキーワードになる可能性がある場合は続行
+      // 例: 「そうで」で止めず「そうでなければ」まで読む
+      // 最長マッチを優先：長いキーワードから短いキーワードへ
+      for (let i = value.length; i >= 1; i--) {
+        const suffix = value.substring(value.length - i);
+        if (KEYWORDS.has(suffix)) {
+          // もっと長いキーワードの可能性をチェック
+          // 次の文字を読んでもキーワードの一部になる可能性があるか？
+          let canExtend = false;
+          if (this.pos < this.source.length) {
+            const nextChar = this.source[this.pos];
+            if (this.isIdentifierChar(nextChar) && 
+                nextChar !== '、' && nextChar !== '，' && 
+                nextChar !== '。' && nextChar !== '．' &&
+                nextChar !== ' ' && nextChar !== '\t' && 
+                nextChar !== '\r' && nextChar !== '\n') {
+              // 次の文字を含めた文字列が、より長いキーワードの接頭辞になるか？
+              const extendedValue = value + nextChar;
+              for (const keyword of KEYWORDS) {
+                if (keyword.startsWith(extendedValue) && keyword.length > suffix.length) {
+                  canExtend = true;
+                  break;
+                }
+              }
+            }
+          }
+          
+          if (!canExtend) {
+            const identifier = value.substring(0, value.length - i);
+            
+            if (identifier.length > 0) {
+              // キーワードの前で止める
+              this.pos -= i;
+              this.col -= i;
+              return new Token(TOKEN_TYPES.IDENTIFIER, identifier, startLine, startCol);
+            } else {
+              // 全体がキーワード
+              return new Token(TOKEN_TYPES.KEYWORD, suffix, startLine, startCol);
+            }
+          }
+        }
+      }
+    }
+
+    // キーワードチェック
+    const type = KEYWORDS.has(value) ? TOKEN_TYPES.KEYWORD : TOKEN_TYPES.IDENTIFIER;
+    return new Token(type, value, startLine, startCol);
+  }
+
+  readOperator() {
+    const startLine = this.line;
+    const startCol = this.col;
+    const char = this.source[this.pos];
+    this.advance();
+    return new Token(TOKEN_TYPES.OPERATOR, char, startLine, startCol);
+  }
+
+  isDigit(char) {
+    return /[0-9]/.test(char);
+  }
+
+  isIdentifierStart(char) {
+    return /[a-zA-Z_あ-んア-ンー一-龯]/.test(char);
+  }
+
+  isIdentifierChar(char) {
+    return /[a-zA-Z0-9_あ-んア-ンー一-龯]/.test(char);
+  }
+
+  isOperator(char) {
+    return /[+\-*/%=<>!()]/.test(char);
+  }
+
+  advance() {
+    this.pos++;
+    this.col++;
+  }
+}
+
+module.exports = { Lexer, Token, TOKEN_TYPES };