converter.js

"use strict";

let fs = require('fs');

let formatChild = (syntax) => {
  return syntax.split(' ').map(token => {
    let matchOpt = /^(.+)\[opt\]$/.exec(token);
    let matchRawString = /^`(.+)`$/.exec(token);

    if (matchOpt !== null) {
      // foo[opt] -> foo.opt
      return `${matchOpt[1]}.opt`;
    } else if (matchRawString !== null) {
      // `foo` -> 'foo'
      let str = matchRawString[1];
      if (str.length > 1) {
        return `"${str}"`;
      } else {
        return `'${str}'`;
      }
    } else {
      return token;
    }
  }).join(' ');
}

fs.readFile('./Syntax.md', (err, data) => {
  let result = '';
  let childCount = 0;
  let endParent = () => {
    childCount = 0;
    result += `;\n\n`;
  };

  let genOptTable = data => {
    let optTable = {};
    let matches = data.toString().match(/([^ ]+)\[opt\]/g);
    matches.forEach(match => {
      let syntax = /^(.+)\[opt\]$/.exec(match)[1];
      optTable[syntax] = true;
    });
    return optTable;
  };

  // optが必要なsyntaxのtable
  let optTable = genOptTable(data);

  data.toString().split('\n').forEach(line => {
    let matchParent = /^- (.+):$/.exec(line);
    let matchChild = /^[ ]+- (.+)$/.exec(line);

    if (matchParent !== null) {
      if (childCount !== 0) {
        endParent();
      }

      let syntax = matchParent[1];

      // add syntax.opt
      if (optTable[syntax]) {
        result += `${syntax}.opt
: /* empty */
| ${syntax}
;

`;
      }

      result += `${syntax}\n`;
    } else if (matchChild !== null) {
      let syntax = formatChild(matchChild[1]);

      ++childCount;

      if (childCount === 1) {
        result += `: ${syntax}\n`;
      } else {
        result += `| ${syntax}\n`;
      }
    } else if (childCount !== 0) {
      endParent();
    }
  });
  console.log(result);
});

result

identifier.opt
: /* empty */
| identifier
;

identifier
: IDENTIFIER
;

constant
: floating-constant
| integer-constant
| enumeration-constant
| character-constant
;

floating-constant
: FLOATING_CONSTANT
;

integer-constant
: INTEGER_CONSTANT
;

enumeration-constant
: identifier
;

character-constant
: CHARACTER_CONSTANT
;

string-literal
: STRING_LITERAL
;

primary-expression
: identifier
| constant
| string-literal
| '(' expression ')'
;

postfix-expression
: primary-expression
| postfix-expression '[' expression ']'
| postfix-expression '(' argument-expression-list.opt ')'
| postfix-expression '.' identifier
| postfix-expression "->" identifier
| postfix-expression "++"
| postfix-expression "--"
;

argument-expression-list.opt
: /* empty */
| argument-expression-list
;

argument-expression-list
: assignment-expression
| argument-expression-list ',' assignment-expression
;

unary-expression
: postfix-expression
| "++" unary-expression
| "--" unary-expression
| unary-operator cast-expression
| "sizeof" unary-expression
| "sizeof" '(' type-name ')'
;

unary-operator
: '&'
| '*'
| '+'
| '~'
| '!'
;

cast-expression
: unary-expression
| '(' type-name ')' cast-expression
;

multiplicative-expression
: cast-expression
| multiplicative-expression '*' cast-expression
| multiplicative-expression '/' cast-expression
| multiplicative-expression '%' cast-expression
;

additive-expression
: multiplicative-expression
| additive-expression '+' multiplicative-expression
| additive-expression '-' multiplicative-expression
;

shift-expression
: additive-expression
| shift-expression "<<" additive-expression
| shift-expression ">>" additive-expression
;

relational-expression
: shift-expression
| relational-expression '<' shift-expression
| relational-expression '>' shift-expression
| relational-expression "<=" shift-expression
| relational-expression ">=" shift-expression
;

equality-expression
: relational-expression
| equality-expression "==" relational-expression
| equality-expression "!=" relational-expression
;

AND-expression
: equality-expression
| AND-expression '&' equality-expression
;

exclusive-OR-expression
: AND-expression
| exclusive-OR-expression '^' AND-expression
;

inclusive-OR-expression
: exclusive-OR-expression
| inclusive-OR-expression '|' exclusive-OR-expression
;

logical-AND-expression
: inclusive-OR-expression
| logical-AND-expression "&&" inclusive-OR-expression
;

logical-OR-expression
: logical-AND-expression
| logical-OR-expression "||" logical-AND-expression
;

conditional-expression
: logical-OR-expression
| logical-OR-expression '?' expression ':' conditional-expression
;

assignment-expression
: conditional-expression
| unary-expression assignment-operator assignment-expression
;

assignment-operator
: '='
| "*="
| "/="
| "%="
| "+="
| "-="
| "<<="
| ">>="
| "&="
| "^="
| "|="
;

expression.opt
: /* empty */
| expression
;

expression
: assignment-expression
| expression ',' assignment-expression
;

constant-expression.opt
: /* empty */
| constant-expression
;

constant-expression
: conditional-expression
;

declaration
: declaration-specifiers init-declarator-list.opt ';'
;

declaration-specifiers.opt
: /* empty */
| declaration-specifiers
;

declaration-specifiers
: storage-class-specifier declaration-specifiers.opt
| type-specifier declaration-specifiers.opt
| type-qualifier declaration-specifiers.opt
;

init-declarator-list.opt
: /* empty */
| init-declarator-list
;

init-declarator-list
: init-declarator
| init-declarator-list ',' init-declarator
;

init-declarator
: declarator
| declarator '=' initializer
;

storage-class-specifier
: "typedef"
| "extern"
| "static"
| "auto"
| "register"
;

type-specifier
: "void"
| "char"
| "short"
| "int"
| "long"
| "float"
| "double"
| "signed"
| "unsigned"
| struct-or-union-specifier
| enum-specifier
| typedef-name
;

struct-or-union-specifier
: struct-or-union identifier.opt '{' struct-declaration-list '}'
| struct-or-union identifier
;

struct-or-union
: "struct"
| "union"
;

struct-declaration-list
: struct-declaration
| struct-declaration-list struct-declaration
;

struct-declaration
: specifier-qualifier-list struct-declarator-list ';'
;

specifier-qualifier-list.opt
: /* empty */
| specifier-qualifier-list
;

specifier-qualifier-list
: type-specifier specifier-qualifier-list.opt
| type-qualifier specifier-qualifier-list.opt
;

struct-declarator-list
: struct-declarator
| struct-declarator-list ',' struct-declarator
;

struct-declarator
: declarator
| declarator.opt ':' constant-expression
;

enum-specifier
: "enum" identifier.opt '{' enumerator-list '}'
| "enum" identifier
;

enumerator-list
: enumerator
| enumerator-list ',' enumerator
;

enumerator
: enumeration-constant
| enumeration-constant '=' constant-expression
;

type-qualifier
: "const"
| "volatile"
;

declarator.opt
: /* empty */
| declarator
;

declarator
: pointer.opt direct-declarator
;

direct-declarator
: identifier
| '{' declarator '}'
| direct-declarator '[' constant-expression.opt ']'
| direct-declarator '(' parameter-type-list ')'
| direct-declarator '(' identifier-list.opt ')'
;

pointer.opt
: /* empty */
| pointer
;

pointer
: '*' type-qualifier-list.opt
| '*' type-qualifier-list.opt pointer
;

type-qualifier-list.opt
: /* empty */
| type-qualifier-list
;

type-qualifier-list
: type-qualifier
| type-qualifier-list type-qualifier
;

parameter-type-list
: parameter-list
| parameter-list ',' "..."
;

parameter-list
: parameter-declaration
| parameter-list ',' parameter-declaration
;

parameter-declaration
: declaration-specifiers declarator
| declaration-specifiers abstract-declarator.opt
;

identifier-list.opt
: /* empty */
| identifier-list
;

identifier-list
: identifier
| identifier-list ',' identifier
;

type-name
: specifier-qualifier-list abstract-declarator.opt
;

abstract-declarator.opt
: /* empty */
| abstract-declarator
;

abstract-declarator
: pointer
| pointer.opt direct-abstract-declarator
;

direct-abstract-declarator.opt
: /* empty */
| direct-abstract-declarator
;

direct-abstract-declarator
: '(' abstract-declarator ')'
| direct-abstract-declarator.opt '[' constant-expression ']'
| direct-abstract-declarator.opt '[' parameter-type-list ']'
;

typedef-name
: identifier
;

initializer
: assignment-expression
| '{' initializer '}'
| '{' initializer-list ',' '}'
;

initializer-list
: initializer
| initializer-list ',' initializer
;

statement
: labeled-statement
| compound-statement
| expression-statement
| selection-statement
| iteration-statement
| jump-statement
;

labeled-statement
: identifier ':' statement
| "case" constant-expression ':' statement
| "default" ':' statement
;

compound-statement
: '{' declaration-list.opt statement-list.opt '}'
;

declaration-list.opt
: /* empty */
| declaration-list
;

declaration-list
: declaration
| declaration-list declaration
;

statement-list.opt
: /* empty */
| statement-list
;

statement-list
: statement
| statement-list statement
;

expression-statement
: expression.opt ';'
;

selection-statement
: "if" '(' expression ')' statement
| "if" '(' expression ')' statement "else" statement
| "switch" '(' expression ')' statement
;

iteration-statement
: "while" '(' expression ')' statement
| "do" statement "while" '(' expression ')' ';'
| "for" '(' expression.opt ';' expression.opt ';' expression.opt ')' statement
;

jump-statement
: "goto" identifier ';'
| "continue" ';'
| "break" ';'
| "return" expression.opt ';'
;

translation-unit
: external-declaration
| translation-unit external-declaration
;

external-declaration
: function-definition
| declaration
;

function-definition
: declaration-specifiers.opt declarator declaration-list.opt compound-statement
;

Syntax.md

6.1 Lexical elements

6.1.2 Identifiers

• identifier:
  • IDENTIFIER

6.1.3 Constants

• constant:
  • floating-constant
  • integer-constant
  • enumeration-constant
  • character-constant

6.1.3.1 Floating constants

• floating-constant:
  • FLOATING_CONSTANT

6.1.3.2 Integer constants

• integer-constant:
  • INTEGER_CONSTANT

6.1.3.3 Enumeration constants

• enumeration-constant:
  • identifier

6.1.3.4 Character constants

• character-constant:
  • CHARACTER_CONSTANT

6.1.4 String literals

• string-literal:
  • STRING_LITERAL

6.3 Expressions

6.3.1 Primary expression

• primary-expression:
  • identifier
  • constant
  • string-literal
  • ( expression )

6.3.2 Postfix operators

• postfix-expression:
  • primary-expression
  • postfix-expression [ expression ]
  • postfix-expression ( argument-expression-list[opt] )
  • postfix-expression . identifier
  • postfix-expression -> identifier
  • postfix-expression ++
  • postfix-expression --
• argument-expression-list:
  • assignment-expression
  • argument-expression-list , assignment-expression

6.3.3 Unary operators

• unary-expression:
  • postfix-expression
  • ++ unary-expression
  • -- unary-expression
  • unary-operator cast-expression
  • sizeof unary-expression
  • sizeof ( type-name )
• unary-operator:
  • &
  • *
  • +
  • ~
  • !

6.3.4 Cast operators

• cast-expression:
  • unary-expression
  • ( type-name ) cast-expression

6.3.5 Multiplicative operators

• multiplicative-expression:
  • cast-expression
  • multiplicative-expression * cast-expression
  • multiplicative-expression / cast-expression
  • multiplicative-expression % cast-expression

6.3.6 Additive operators

• additive-expression:
  • multiplicative-expression
  • additive-expression + multiplicative-expression
  • additive-expression - multiplicative-expression

6.3.7 Bitwise shift operators

• shift-expression:
  • additive-expression
  • shift-expression << additive-expression
  • shift-expression >> additive-expression

6.3.8 Relational operators

• relational-expression:
  • shift-expression
  • relational-expression < shift-expression
  • relational-expression > shift-expression
  • relational-expression <= shift-expression
  • relational-expression >= shift-expression

6.3.9 Equality operators

• equality-expression:
  • relational-expression
  • equality-expression == relational-expression
  • equality-expression != relational-expression

6.3.10 Bitwise AND operator

• AND-expression:
  • equality-expression
  • AND-expression & equality-expression

6.3.11 Bitwise exclusive OR operator

• exclusive-OR-expression:
  • AND-expression
  • exclusive-OR-expression ^ AND-expression

6.3.12 Bitwise inclusive OR operator

• inclusive-OR-expression:
  • exclusive-OR-expression
  • inclusive-OR-expression | exclusive-OR-expression

6.3.13 Logical AND operator

• logical-AND-expression:
  • inclusive-OR-expression
  • logical-AND-expression && inclusive-OR-expression

6.3.14 Logical OR operator

• logical-OR-expression:
  • logical-AND-expression
  • logical-OR-expression || logical-AND-expression

6.3.15 Conditional operator

• conditional-expression:
  • logical-OR-expression
  • logical-OR-expression ? expression : conditional-expression

6.3.16 Assignment operators

• assignment-expression:
  • conditional-expression
  • unary-expression assignment-operator assignment-expression
• assignment-operator:
  • =
  • *=
  • /=
  • %=
  • +=
  • -=
  • <<=
  • >>=
  • &=
  • ^=
  • |=

6.3.17 Comma operator

• expression:
  • assignment-expression
  • expression , assignment-expression

6.4 Constant expression

• constant-expression:
  • conditional-expression

6.5 Declarations

• declaration:
  • declaration-specifiers init-declarator-list[opt] ;
• declaration-specifiers:
  • storage-class-specifier declaration-specifiers[opt]
  • type-specifier declaration-specifiers[opt]
  • type-qualifier declaration-specifiers[opt]
• init-declarator-list:
  • init-declarator
  • init-declarator-list , init-declarator
• init-declarator:
  • declarator
  • declarator = initializer

6.5.1 Storage-class specifiers

• storage-class-specifier:
  • typedef
  • extern
  • static
  • auto
  • register

6.5.2 Type specifiers

• type-specifier:
  • void
  • char
  • short
  • int
  • long
  • float
  • double
  • signed
  • unsigned
  • struct-or-union-specifier
  • enum-specifier
  • typedef-name

6.5.2.1 Structure and union specifiers

• struct-or-union-specifier:
  • struct-or-union identifier[opt] { struct-declaration-list }
  • struct-or-union identifier
• struct-or-union:
  • struct
  • union
• struct-declaration-list:
  • struct-declaration
  • struct-declaration-list struct-declaration
• struct-declaration:
  • specifier-qualifier-list struct-declarator-list ;
• specifier-qualifier-list:
  • type-specifier specifier-qualifier-list[opt]
  • type-qualifier specifier-qualifier-list[opt]
• struct-declarator-list:
  • struct-declarator
  • struct-declarator-list , struct-declarator
• struct-declarator:
  • declarator
  • declarator[opt] : constant-expression

6.5.2.2 Enumeration specifiers

• enum-specifier:
  • enum identifier[opt] { enumerator-list }
  • enum identifier
• enumerator-list:
  • enumerator
  • enumerator-list , enumerator
• enumerator:
  • enumeration-constant
  • enumeration-constant = constant-expression

6.5.3 Type qualifiers

• type-qualifier:
  • const
  • volatile

6.5.4 Declarators

• declarator:
  • pointer[opt] direct-declarator
• direct-declarator:
  • identifier
  • { declarator }
  • direct-declarator [ constant-expression[opt] ]
  • direct-declarator ( parameter-type-list )
  • direct-declarator ( identifier-list[opt] )
• pointer:
  • * type-qualifier-list[opt]
  • * type-qualifier-list[opt] pointer
• type-qualifier-list:
  • type-qualifier
  • type-qualifier-list type-qualifier
• parameter-type-list:
  • parameter-list
  • parameter-list , ...
• parameter-list:
  • parameter-declaration
  • parameter-list , parameter-declaration
• parameter-declaration:
  • declaration-specifiers declarator
  • declaration-specifiers abstract-declarator[opt]
• identifier-list:
  • identifier
  • identifier-list , identifier

6.5.5 Types names

• type-name:
  • specifier-qualifier-list abstract-declarator[opt]
• abstract-declarator:
  • pointer
  • pointer[opt] direct-abstract-declarator
• direct-abstract-declarator:
  • ( abstract-declarator )
  • direct-abstract-declarator[opt] [ constant-expression ]
  • direct-abstract-declarator[opt] [ parameter-type-list ]

6.5.6 Type definitions

• typedef-name:
  • identifier

6.5.7 Initialization

• initializer:

  • assignment-expression
  • { initializer }
  • { initializer-list , }

• initializer-list:

  • initializer
  • initializer-list , initializer

6.6 Statements

• statement:
  • labeled-statement
  • compound-statement
  • expression-statement
  • selection-statement
  • iteration-statement
  • jump-statement

6.6.1 Labeled statements

• labeled-statement:
  • identifier : statement
  • case constant-expression : statement
  • default : statement

6.6.2 Compound statement, or block

• compound-statement:
  • { declaration-list[opt] statement-list[opt] }
• declaration-list:
  • declaration
  • declaration-list declaration
• statement-list:
  • statement
  • statement-list statement

6.6.3 Expression and null statements

• expression-statement:
  • expression[opt] ;

6.6.4 Selection statements

• selection-statement:
  • if ( expression ) statement
  • if ( expression ) statement else statement
  • switch ( expression ) statement

6.6.5 Iteration statements

• iteration-statement:
  • while ( expression ) statement
  • do statement while ( expression ) ;
  • for ( expression[opt] ; expression[opt] ; expression[opt] ) statement

6.6.6 Jump statements

• jump-statement:
  • goto identifier ;
  • continue ;
  • break ;
  • return expression[opt] ;

6.7 External definitions

• translation-unit:

  • external-declaration
  • translation-unit external-declaration

• external-declaration:

  • function-definition
  • declaration

6.7.1 Function definitions

• function-definition:
  • declaration-specifiers[opt] declarator declaration-list[opt] compound-statement