onelang/langs/php.yaml

OneLang transpiler framework core

name: php
extension: php
casing: # based on https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-1-basic-coding-standard.md
  class: pascal_case
  method: camel_case
  field: snake_case
  property: snake_case
  variable: snake_case
  enum: pascal_case
  enumMember: pascal_case  
templates:
  testGenerator: |-
    try {
        $c = new {{class}}();
        $c->{{method}}();
    } catch (Exception $err) {
        echo 'Exception: ' . $err->getMessage() . "\n";
    }

  main: |-
    <?php

    {{for inc in includes|sep=\n}}
      require_once("{{inc.source}}.php");
    {{/for}}

    {{for enum in enums|sep=\n\n}}
      class {{enum.name}} { 
          {{for item in enum.values}}
            const {{item.name}} = {{item.intValue}};
          {{/for}}
      }
    {{/for}}

    {{for class in classes|sep=\n\n}}
      class {{class.name}}{{if class.baseClass}} extends {{class.baseClass}}{{/if}} {
          {{for field in class.fields|sep=\n}}
            {{field.visibility}} {{if field.static}}static {{/if}}${{field.name}}
            {{if field.initializer|inline}}
               = {{gen(field.initializer)}}
            {{/if}}
            ;
          {{/for}}

          {{if class.constructor}}
            function __construct({{genArgs(class.constructor)}}) {
                {{genBody(class.constructor.body)}}
            }
          {{/if}}

          {{for method in class.methods|sep="\n    \n"}}
            {{if config.genMeta}}
              // @signature {{method.name}}(
              {{for param in method.parameters|inline sep=", "}}
                {{param.name}}: {{if param.typeInfo}}{{param.typeInfo.oneName}}{{else}}???{{/if}}
              {{/for}}
              ): {{if method.returnTypeInfo}}{{method.returnTypeInfo.oneName}}{{else}}???{{/if}}
            {{/if}}          
            {{if method.static}}static {{/if}}function {{method.name}}({{genArgs(method)}}) {
                {{genBody(method.body)}}
            }
          {{/for}}
      }

      {{endClass(class)}}
    {{/for}}

    {{genBody(mainBlock)}}

  genBody:
    args:
      - name: body
    template: |-
      {{for statement in body.statements|sep=\n}}
        {{statement.leadingTrivia}}{{gen(statement)}}
      {{/for}}

  genArgs:
    args:
      - name: method
    template: |-
      {{for param in method.parameters|sep=", "}}
        ${{param.name}}
      {{/for}}
  genParams:
    args:
      - name: params
    template: |-
      {{for param in params|sep=", " inline}}
        {{gen(param)}}
      {{/for}}
  genVar:
    args:
      - name: itemVar
    template: "${{itemVar.outName}} = {{gen(itemVar.initializer)}}"
  genWithParen:
    args: [{ name: expr }]
    template: |-
      {{if expr.exprKind == "Binary" or expr.exprKind == "Conditional"}}
        ({{gen(expr)}})
      {{else}}
        {{gen(expr)}}
      {{/if}}
expressions:
  call: |-
    {{gen(expr.method)}}(
      {{for arg in expr.arguments|sep=", " inline}}
        {{gen(arg)}}
      {{/for}}
    )
  identifier: "${{expr.text}}"
  stringLiteral: '"{{expr.escapedText}}"'
  characterLiteral: '"{{expr.escapedText}}"'
  nullLiteral: "NULL"
  return: "return{{if expr.expression}} {{gen(expr.expression)}}{{/if}};"
  binary: "{{gen(expr.left)}} {{expr.operator}} {{gen(expr.right)}}"
  postfix: "{{gen(expr.operand)}}{{expr.operator}}"
  prefix: "{{expr.operator}}{{gen(expr.operand)}}"
  throw: "throw {{gen(expr.expression)}};"
  parenthesized: "({{gen(expr.expression)}})"
  numericLiteral: "{{expr.value}}"
  variableDeclaration: "{{genVar(expr)}};"
  new: "new {{gen(expr.cls)}}({{genParams(expr.arguments)}})"
  classReference: "{{expr.classRef.outName}}"
  enumReference: "{{expr.enumRef.outName}}"
  enumMemberReference: "{{expr.enumRef.outName}}::{{expr.enumMemberRef.outName}}"
  expressionStatement: "{{gen(expr.expression)}};"
  instanceMethod: "{{gen(expr.thisExpr)}}->{{expr.methodRef.outName}}"
  staticMethod: "{{expr.methodRef.classRef.outName}}::{{expr.methodRef.outName}}"
  localVar: "${{expr.varRef.outName}}"
  methodArgument: "${{expr.varRef.outName}}"
  instanceField: "{{gen(expr.thisExpr)}}->{{expr.varRef.outName}}"
  staticField: "{{gen(expr.thisExpr)}}::${{expr.varRef.outName}}"
  falseLiteral: "false"
  trueLiteral: "true"
  elementAccess: "{{gen(expr.object)}}[{{gen(expr.elementExpr)}}]"
  thisReference: "$this"
  conditional: "{{gen(expr.condition)}} ? {{genWithParen(expr.whenTrue)}} : {{genWithParen(expr.whenFalse)}}"
  break: break;
  templateString: |-
    {{for part in expr.parts|inline sep=" . "}}
      {{if part.literal && part.text != ""|inline}}
        "{{escapeQuotes(part.text)}}"
      {{else}}
        {{if part.expr.valueType.isBoolean|inline}}
          ({{genWithParen(part.expr)}} ? "true" : "false")
        {{else}}
          {{genWithParen(part.expr)}}
        {{/if}}
      {{/if}}
    {{/for}}
  foreach: |-
    foreach ({{gen(expr.items)}} as ${{expr.itemVariable.outName}}) {
        {{genBody(expr.body)}}
    }
  for: |-
    for ({{genVar(expr.itemVariable)}}; {{gen(expr.condition)}}; {{gen(expr.incrementor)}}) {
        {{genBody(expr.body)}}
    }
  while: |-
    while ({{gen(expr.condition)}}) {
        {{genBody(expr.body)}}
    }
  if: |-
    if ({{gen(expr.condition)}}) {
        {{genBody(expr.then)}}
    }
    {{if expr.else|inline}}
      {{" "}}
      {{if isIfBlock(expr.else)|inline}}
        else{{genBody(expr.else)}}
      {{else}}
        else {
            {{genBody(expr.else)}}
        }
      {{/if}}
    {{/if}}