grammar.peg

{
  function reduceRightRecursion(head, tail) {
    tail = tail.map(e => e[e.length - 1]) ?? [];
    return [head, ...tail];
  };
  
  function concatInPlace(dest, src) {
      for (const e of src) {
          dest.push(e);
      }
  };

  const Type = {
    INT: 'i',
    UINT: 'u',
    LONG: 'l',
    ULONG: 'ul',
    LONG_LONG: 'll',
    ULONG_LONG: 'ull',
  };
}

Main
  = XDeclarationList / FormatCall

FormatCall "printf-scanf-call"
  = FormatScope?
    fname:(PrintfFunctionName / ScanfFunctionName)
    _ "(" _ args:FormatArguments? _ ")" (_ ";")* _ {
      return {
      	  formatArgs: args ?? [],
          functionName: fname
      };
  }

FormatScope
  = _ ("::"? _ "std" _ "::" _)

PrintfFunctionName
  = ("f" / "s" / "sn")? "printf" "_s"? {
      return text();
  }

ScanfFunctionName
  = ("scanf" / "fscanf" / "sscanf") "_s"? {
      return text();
  }

FormatArguments
  = head:FormatArgument tail:(_ "," _ FormatArgument)* {
      return reduceRightRecursion(head, tail);
  }

FormatArgument
  = StringLiteral / FormatArgExpr

StringLiteral
  = '"' value:StringLiteralContents '"' {
      return {
          typ: "string",
          // use base 64 encoding because PEG.js has issues with
          // string escape characters
          value: btoa(value)
      };
  }

StringLiteralContents
  = ('\\"' / "\\" c:[^"] / [^\"])* {
      return text();
  }

FormatArgExpr
  = expr:UnaryExpr {
    return {typ: "expr", value: expr.trim()};
  }

UnaryExpr
  = PrefixExpr {
      return text();
  }

ParenthesizedExpr
  = _ "(" UnaryExpr _ ")"

PrefixExpr
  = _ (_ ("++" / "+" / "--" / "-" / "&" / "*" / "!" / "~" / "(" DeclarationSpecifiers AbstractDeclarator? _ ")"))* PostfixExpr

PostfixExpr
  = PrimaryExpr (_ ("(" UnaryExpr _ ")" / "[" UnaryExpr _"]" / "++" / "--"))*

PrimaryExpr
  = _ Identifier / _ IntegerConstant / _ "(" UnaryExpr _")"

// DECLARATIONS

XDeclarationList
  = head:Declaration tail:(_ ";" _ Declaration?)* {
    return reduceRightRecursion(head, tail)
      .filter(x => x !== null);
  }

Declaration "declaration"
  = declSpecs:DeclarationSpecifiers _ list:InitDeclaratorList {
    return {specifiers: declSpecs, declarators: list};
  }

DeclarationSpecifiers "declaration-specifier-list"
  = head:TypedefName tail:(__ XNoTypedefDeclarationSpecifier)* {
    return reduceRightRecursion(head, tail);
  }
  / head:DeclarationSpecifier tail:(__ DeclarationSpecifier)* {
    return reduceRightRecursion(head, tail);
  }

DeclarationSpecifier "declaration-specifier"
  = XNoTypedefDeclarationSpecifier / TypedefName

XNoTypedefDeclarationSpecifier "x-no-typedef-declaration-specifier"
  = StorageClassSpecifier
  / XNoTypedefTypeSpecifier
  / TypeQualifier
  / FunctionSpecifier

InitDeclaratorList "init-declarator-list"
  = head:InitDeclarator tail:(Comma InitDeclarator)* {
    return reduceRightRecursion(head, tail);
  }
  / it:AbstractDeclarator? {
    return it ? [it] : [[]];
  }

InitDeclarator "init-declarator"
  = decl:Declarator XBraceInitializer? {
    return decl;
  }

XBraceInitializer "x-brace-initializer"
  = _ "{" _ "}"

StorageClassSpecifier "storage-class-specifier"
  = it:("typedef"
  / "extern"
  / "static"
  / ThreadLocalKeyword
  / "auto"
  / "constexpr"
  / "register") !WordChar {
    return ["storage-class-specifier", it];
  }

TypeSpecifier "type-specifier"
  = XNoTypedefTypeSpecifier / TypedefName

XNoTypedefTypeSpecifier "x-no-typedef-type-specifier"
  = it:("void" / "char" / "short" / "int" / "long" / "float" / "double" / "signed" / "unsigned" / ComplexKeyword / BoolKeyword) !WordChar
  { return ["type-specifier", it]; }
  / AtomicTypeSpecifier
  / StructOrUnionSpecifier
  / EnumSpecifier

StructOrUnionSpecifier "struct-or-union-specifier"
  =  kind:$("struct" / "union" / "class") __ id:Identifier !WordChar (_ "{" _ "}")? {
    return ["struct-or-union-specifier", kind, id];
  }
  / kind:$("struct" / "union" / "class") _ "{" _ "}" {
    return ["struct-or-union-specifier", kind];
  }

EnumSpecifier "enum-specifier"
  = "enum" __ id:Identifier !WordChar {
      return ["enum-specifier", id];
  }

AtomicTypeSpecifier "atomic-type-specifier"
  = AtomicKeyword _ "(" _ name:TypeName _ ")" {
    return ["atomic-type-specifier", name];
  }

TypeQualifier "type-qualifier"
  = it:("const" / "restrict" / "volatile") !WordChar {
    return ["type-qualifier", it];
  }
  / it:AtomicKeyword !(_ "(" / WordChar) {
    return ["type-qualifier", it];
  }

FunctionSpecifier "function-specifier"
  = it:("inline" / NoreturnKeyword) !WordChar {
    return ["function-specifier", it];
  }

Declarator "declarator"
  = ptr:XPrefix? _ decl:DirectDeclarator {
    return decl.concat(ptr ?? []);
  }

DirectDeclarator "direct-declarator"
  = scoped:XScopedDeclarator _ postfix:XPostfix* {
    return scoped.concat(postfix ?? []);
  }

XScopedDeclarator "x-scoped-declarator"
  = scope:XScope? _ id:Identifier !(_ "::") {
    return [{typ: "id", id: id}].concat(scope ?? []);
  }
  / scope:XScope _ decl:Declarator {
    return decl.concat(scope);
  }
  / _ "(" _ decl:Declarator _ ")" {
    return decl;
  }

AbstractDeclarator "abstract-declarator"
  = ptr:XPrefix? _ decl:DirectAbstractDeclarator {
    return decl.concat(ptr ?? []);
  }
  / XPrefix

DirectAbstractDeclarator "direct-abstract-declarator"
  = pre:XScopedAbstractDeclarator? postfix:XPostfix+ {
    return (pre ?? []).concat(postfix);
  }
  / pre:XScopedAbstractDeclarator {
    return pre;
  }

XScopedAbstractDeclarator "x-scoped-abstract-declarator"
  = scope:XScope _ decl:AbstractDeclarator {
    return decl.concat(scope);
  }
  / _ "(" _ decl:AbstractDeclarator _ ")" _ {
    return decl;
  }

XPostfix "x-postfix"
  = _ "[" _ qual:TypeQualifierList size:(__ IntegerConstant)? _ "]" _ {
    const q = qual.map(e => e[1]);
    const s = size ? size[1] : null;
    return {typ: "[]", statik: false, qualifiers: q, size: s};
  }
  / _ "[" _  size:IntegerConstant? _ "]" _ {
    return {typ: "[]", statik: false, qualifiers: [], size: size};
  }
  / _ "[" _ statik:("static" __) qual:(TypeQualifierList __)? size:IntegerConstant _ "]" _ {
    const q = (qual ? qual[0] : []).map(e => e[1]);
    return {typ: "[]", statik: true, qualifiers: q, size: size};
  }
  / _ "[" _ qual:TypeQualifierList __ statik:("static" __) size:IntegerConstant _ "]" _ {
    const q = (qual ?? []).map(e => e[1]);
    return {typ: "[]", statik: true, qualifiers: q, size: size};
  }
  / _ "[" _ qual:TypeQualifierList? _ "*" _ "]" _ {
    return {typ: "[*]", qualifiers: (qual ?? []).map(e => e[1])};
  }
  / _ "(" _ params:ParameterTypeList? _ ")" _ q:FunctionQualifierList {
    return {typ: "()", params: params ?? [], qualifiers: q};
  }

XScope "x-scope"
  = head:Identifier? _ "::" tail:(_ Identifier "::")* !(_ ("(" / "[")) {
    return [{typ: "::", id: head}].concat(tail
        .map(e => e[1])
        .map(e => ({typ: "::", id: e})))
        .reverse();
  }

XPrefix "x-prefix"
  = list:(Pointer / XReferenceItem)+ {
    return [].concat(...list.reverse());
  }

Pointer "pointer"
  = head:XPointerItem+  {
    return head.map(e => ({typ: '*', qualifiers: e})).reverse();
  }

XPointerItem "x-pointer-item"
  = _ "*" _ list:TypeQualifierList? {
    return (list ?? []).map(e => e[1]);
  }

XReferenceItem "x-reference-item"
  = _ it:("&&" / "&") _ {
    return {typ: it};
  }

TypeQualifierList "type-qualifier-list"
  = head:TypeQualifier tail:(__ TypeQualifier)* {
    return reduceRightRecursion(head, tail);
  }

FunctionQualifierList "x-function-qualifier-list"
  = cv:TypeQualifierList? ref:(_ "&&" / _ "&") virt:(_ OverrideFinal)? {
    return [...(cv ?? []), ref].map(e => e[1])
                       .concat(virt ? [virt[1]] : []);
  }
  / cv:TypeQualifierList virt:(__ OverrideFinal)? {
    return [...cv].map(e => e[1])
                  .concat(virt ? [virt[1]] : []);
  }
  / it:OverrideFinal? {
    return it ? [it] : [];
  }

OverrideFinal "x-override-final"
  = it:("override" !WordChar / "final" !WordChar) {
    return it[0];
  }

ParameterTypeList "parameter-type-list"
  = head:ParameterList ellipsis:(_ ","? _ "..." _)? {
    return head.concat(ellipsis ? [{typ: "..."}] : []);
  }
  / _ "..." _ {
    return [{typ: "..."}];
  }

ParameterList "parameter-list"
  = head:ParameterDeclaration tail:(Comma ParameterDeclaration)* {
    return reduceRightRecursion(head, tail);
  }

ParameterDeclaration "parameter-declaration"
  = spec:DeclarationSpecifiers _ decl:(Declarator / AbstractDeclarator)? {
    return {typ: "decl", specifiers: spec, declarator: decl ?? []};
  }

TypeName "type-name"
  = list:SpecifierQualifierList _ decl:AbstractDeclarator? {
    return {specifiers: list, declarator: decl ?? []};
  }

TypedefName "typedef-name"
  = id:KnownAlias !WordChar {
    return ["typedef-name", id];
  }

SpecifierQualifierList "specifier-qualifier-list"
  = head:(TypeSpecifier / TypeQualifier) tail:(__ (TypeSpecifier / TypeQualifier))* {
    return reduceRightRecursion(head, tail);
  }

// LEXICAL ELEMENTS

Identifier "identifier"
  = !(Keyword !WordChar) [a-zA-Z_]WordChar* {
      return text();
  }

IntegerConstant "integer-constant"
  = value:(BinaryConstant / HexadecimalConstant / OctalConstant / DecimalConstant) typ:IntegerSuffix? {
    return {base: value[0], value: value[1], typ: typ ?? Type.INT};
  }

BinaryConstant "binary-constant"
  = "0"[bB] digits:$[01]+ {
    return [2, Number.parseInt(digits, 2)];
  }

HexadecimalConstant "hexadecimal-constant"
  = "0"[xX] digits:$[0-9a-fA-F]+ {
    return [16, Number.parseInt(digits, 16)];
  }

OctalConstant "octal-constant"
  = "0"+ digits:$[0-7]* {
    return [8, digits ? Number.parseInt(digits, 8) : 0];
  }

DecimalConstant "decimal-constant"
  = [1-9][0-9]* {
    return [10, Number.parseInt(text(), 10)];
  }

IntegerSuffix "integer-suffix"
  = ([uU][lL]?[lL]? / [lL]?[lL]?[uU]?) {
    const res = text().toLowerCase();
    return res.startsWith('u') || res.endsWith('u') ?
       [Type.UINT, Type.ULONG, Type.ULONG_LONG][res.length - 1] :
       [Type.INT, Type.LONG, Type.LONG_LONG][res.length];
  }

Keyword "keyword"
  = "auto"
  / "break"
  / "case"
  / "constexpr"
  / "char"
  / "const"
  / "continue"
  / "default"
  / "do"
  / "double"
  / "else"
  / "enum"
  / "extern"
  / "float"
  / "for"
  / "goto"
  / "if"
  / "inline"
  / "int"
  / "long"
  / "register"
  / "restrict"
  / "return"
  / "short"
  / "signed"
  / "sizeof"
  / "static"
  / "struct"
  / "switch"
  / "typedef"
  / "union"
  / "unsigned"
  / "void"
  / "volatile"
  / "while"
  / AlignasKeyword
  / AlignofKeyword
  / AtomicKeyword
  / BoolKeyword
  / ComplexKeyword
  / GenericKeyword
  / ImaginaryKeyword
  / NoreturnKeyword
  / StaticAssertKeyword
  / ThreadLocalKeyword

KnownAlias
  = "FILE" / PosixAlias

PosixAlias = ([a-zA-Z_](!"_t" WordChar)*) "_t" { return text(); }

AlignasKeyword
  = ("_Alignas" / "alignas") { return "alignas"; }

AlignofKeyword
  = ("_Alignof" / "alignof") { return "alignof"; }

AtomicKeyword
  = "_Atomic"

BoolKeyword
  = ("_Bool" / "bool") { return "bool"; }

ComplexKeyword
  = ("_Complex" / "complex") { return "complex"; }

GenericKeyword
  = "_Generic"

ImaginaryKeyword
  = ("_Imaginary" / "imaginary") { return "imaginary"; }

NoreturnKeyword
  = "_Noreturn"

StaticAssertKeyword
  = ("_Static_assert" / "static_assert") { return "static_assert"; }

ThreadLocalKeyword
  = ("_Thread_local" / "thread_local") { return "thread_local"; }

// WHITESPACE AND SEPARATORS

WordChar
  = [a-zA-Z0-9_]

Comma "comma"
  = _ "," _

_ "whitespace"
  = [ \n]?

__ "mandatory-whitespace"
  = [ \n]