onelang/langs/cpp.yaml

OneLang transpiler framework core

name: cpp
extension: cpp
casing:
  class: pascal_case
  method: camel_case
  field: snake_case
  property: snake_case
  variable: snake_case
  enum: pascal_case
  enumMember: pascal_case
primitiveTypes:
  void: void
  any: any
templates:
  testGenerator: |-
    int main()
    {
        try {
            {{class}} c;
            c.{{method}}();
        } catch(std::exception& err) {
            std::cout << "Exception: " << err.what() << '\n';
        }
        return 0;
    }

  main: |-
    #include <one.hpp>
    {{for inc in includes|sep=\n}}
      #include <{{inc.source}}>
    {{/for}}

    {{for enum in enums|sep=\n}}
      enum class {{enum.name}} { 
      {{for item in enum.values|inline sep=", "}}
        {{item.name}}
      {{/for}}
       };
      const char* {{enum.name}}ToStr[] = { 
      {{for item in enum.values|inline sep=", "}}
        "{{item.origName}}"
      {{/for}}
       };
    {{/for}}

    {{for interface in interfaces|sep=\n\n}}
      {{genClassSignature(interface)}} {
        public:
          {{for method in interface.methods|sep="\n    \n"}}
            virtual {{getType(method.returnTypeInfo)}} {{method.name}}({{genArgs(method)}}) = 0;
          {{/for}}
      };
    {{/for}}

    {{for class in classes|sep=\n\n}}
      {{genClassSignature(class)}} {
        public:
          {{genFields(class.publicFields)}}

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

          {{genMethods(class.publicMethods)}}

        private:
          {{genFields(class.privateFields)}}

          {{genMethods(class.privateMethods)}}
      };

      {{for field in class.fields|sep=\n}}
        {{if field.static && field.initializer}}
          {{getType(field.typeInfo)}} {{class.name}}::{{field.name}} = {{gen(field.initializer)}};
        {{/if}}
      {{/for}}
      
      {{afterClass(class)}}
    {{/for}}

    {{if mainBlock.statements.length > 0}}
      int main()
      {
          {{genBody(mainBlock)}}
          return 0;
      }
    {{/if}}
    
  genFields:
    args:
      - name: fields
    template: |-
      {{for field in fields|sep=\n}}
        {{if field.static}}static {{/if}}{{getType(field.typeInfo)}} {{field.name}}{{if !field.static && field.initializer}} = {{gen(field.initializer)}}{{/if}};
      {{/for}}

  getType:
    args:
      - name: item
    template: |-
      {{if item.isComplexClass && !item.isOneArray}}
        sp<{{typeName(item)}}>
      {{elif item.isOneArray}}
        vec<{{getType(item.typeArguments[0])}}>
      {{else}}
        {{typeName(item)}}
      {{/if}}

  getTypeX:
    args:
      - name: type
    template: "{{typeName(type)}}{{if type.isComplexClass}}*{{/if}}"

  genMethods:
    args:
      - name: methods
    template: |-
      {{for method in methods|sep=\n\n}}
        {{if method.static}}static {{/if}}{{if method.attributes["virtual"]}}virtual {{/if}}{{getType(method.returnTypeInfo)}} {{method.name}}({{genArgs(method)}}) {
            {{genBody(method.body)}}
        }
      {{/for}}

  genClassSignature:
    args: [{name: class}]
    template: |-
      {{if class.typeArguments|inline}}
        template<
        {{for arg in class.typeArguments|inline sep=", "}}
          typename {{arg}}
        {{/for}}
        >
      {{/if}}
      class {{class.name}}
      {{if class.baseClasses.length > 0 or class.attributes["reflect"]|inline}}
         : 
        {{for item in class.baseClasses|inline sep=", "}}
          public {{item}}
        {{/for}}
        {{if class.attributes["reflect"]}}
          {{if class.baseClasses.length > 0}}, {{/if}}public ReflectedClass
        {{/if}}
      {{/if}}

  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.type}} {{param.name}}
      {{/for}}
  genParams:
    args:
      - name: params
    template: |-
      {{for param in params|sep=", " inline}}
        {{gen(param)}}
      {{/for}}
  genVar:
    args:
      - name: itemVar
    template: |-
      {{if itemVar.type.isNumber}}int{{else}}auto{{/if}} {{itemVar.outName}} = {{gen(itemVar.initializer)}}
  genWithParen:
    args: [{ name: expr }]
    template: |-
      {{if expr.exprKind == "Binary" or expr.exprKind == "Conditional"}}
        ({{gen(expr)}})
      {{else}}
        {{gen(expr)}}
      {{/if}}
  afterClass: { args: [class], template: "" }
expressions:
  call: |-
    {{gen(expr.method)}}(
      {{for arg in expr.arguments|sep=", " inline}}
        {{gen(arg)}}
      {{/for}}
    )
  propertyAccess: "{{gen(expr.object)}}->{{gen(expr.propertyName)}}"
  identifier: "{{expr.text}}"
  stringLiteral: 'std::string("{{expr.escapedText}}")'
  characterLiteral: "'{{expr.escapedTextSingle}}'"
  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}}"
  nullLiteral: "nullptr"
  variableDeclaration: "{{genVar(expr)}};"
  new: |-
    std::make_shared<{{gen(expr.cls)}}
      {{if expr.typeArguments.length > 0|inline}}
        <
        {{for arg in expr.typeArguments|inline sep=", "}}
          {{typeName(arg)}}
        {{/for}}
        >
      {{/if}}
    >({{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
  cast: "static_cast<{{typeName(expr.newType)}}>({{gen(expr.expression)}})"
  conditional: "{{gen(expr.condition)}} ? {{gen(expr.whenTrue)}} : {{gen(expr.whenFalse)}}"
  templateString: |-
    {{for part in expr.parts|sep=" + " inline}}
      {{if part_idx == 0|inline}}std::string({{/if}}
      {{if part.literal|inline}}
        "{{escapeQuotes(part.text)}}"
      {{elif part.expr.valueType.isNumber|inline}}
        std::to_string({{gen(part.expr)}})
      {{elif part.expr.valueType.isEnum|inline}}
        {{part.expr.valueType.enumName}}ToStr[(int)({{gen(part.expr)}})]
      {{elif part.expr.valueType.isBoolean|inline}}
        ({{genWithParen(part.expr)}} ? "true" : "false")
      {{else}}
        {{genWithParen(part.expr)}}
      {{/if}}
      {{if part_idx == 0|inline}}){{/if}}
    {{/for}}
  foreach: |-
    for (auto it = {{gen(expr.items)}}->begin(); it != {{gen(expr.items)}}->end(); ++it) {
        auto {{expr.itemVariable.outName}} = *it;
        {{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)}}
    }
  break: break;
  if: |-
    if ({{gen(expr.condition)}}) {
        {{genBody(expr.then)}}
    }
    {{if expr.else|inline}}
      {{" "}}
      {{if isIfBlock(expr.else)|inline}}
        else {{genBody(expr.else)|inline}}
      {{else}}
        else {
            {{genBody(expr.else)}}
        }
      {{/if}}
    {{/if}}