package processing.mode.cpp;

import java.io.*;

import java.util.*;

import java.nio.charset.StandardCharsets;

/**

* Standalone CLI translator for the web compile server.

* Reads PDE/Java-style sketch from stdin, outputs C++ to stdout.

*/

public class CppCLI {

// Single source of truth for lifecycle method names -- defined in CppBuild.

private static final Set<String> LIFECYCLE = CppBuild.LIFECYCLE_METHOD_NAMES;

public static void main(String[] args) throws Exception {

String input = new String(System.in.readAllBytes(), StandardCharsets.UTF_8);

try {

System.out.print(translate(input));

} catch (Exception e) {

System.err.println(e.getMessage());

System.exit(1);

}

}

private static String translate(String input) throws Exception {

// Delegate all pre-AST transforms to prepareCode() -- single source of truth.

CppBuild.PreparedCode prepared = CppBuild.prepareCode(input);

String code = prepared.code;

boolean hasSetup = code.contains("void setup(");

boolean hasDraw = code.contains("void draw(");

// __has_include blocks go to file scope directly -- never into the parser.

StringBuilder hasIncludePreNs = new StringBuilder();

for (String block : prepared.hasIncludeBlocks.values()) {

hasIncludePreNs.append(block);

}

StringBuilder out = new StringBuilder();

StringBuilder preNs = new StringBuilder();

appendHeader(out);

if (hasSetup || hasDraw) {

String result = runPipeline(code, preNs);

System.out.print(hasIncludePreNs);

System.out.print(preNs);

System.out.print(out);

System.out.print(result);

if (!code.contains("int main")) {

System.out.print("\nint main() { Processing::_PSketch sketch; sketch.run(); return 0; }\n");

}

return "";

} else if (code.contains("int main")) {

return hasIncludePreNs.toString() + preNs.toString() + out.toString() + code;

} else {

out.append("\nnamespace Processing {\n\n");

out.append(code);

out.append("\n} // namespace Processing\n\n");

out.append("int main() { Processing::_PSketch sketch; sketch.run(); return 0; }\n");

return hasIncludePreNs.toString() + preNs.toString() + out.toString();

}

}

private static String runPipeline(String code, StringBuilder preNs) throws Exception {

CompilationUnit cu = Parser.parse(code);

CppBuild.AstPipelineResult pipe = CppBuild.runAstPipeline(cu);

StringBuilder sb = new StringBuilder();

sb.append("\nnamespace Processing {\n\n");

// Route preprocessor directives and namespace decls to file scope or namespace body.

List<TopLevelItem> effectiveRest = new ArrayList<>();

for (TopLevelItem item : pipe.filteredRest) {

if (item instanceof PreprocessorLine pl) {

if (CppBuild.isFileScopePreprocessorLine(pl)) preNs.append(CodeGen.generateNode(item, 0));

else sb.append(CodeGen.generateNode(item, 0));

continue;

}

if (item instanceof NamespaceDecl nd) {

if (nd.name().equals("std")) preNs.append(CodeGen.generateNode(nd, 0));

else sb.append(CodeGen.generateNode(nd, 0));

continue;

}

if (item instanceof UsingNamespaceDecl) {

sb.append(CodeGen.generateNode(item, 0)); continue;

}

effectiveRest.add(item);

}

// Emit in same order as writeSketchImpl.

for (TopLevelItem e : pipe.enumResult.enums) sb.append(CodeGen.generateNode(e, 0));

for (FunctionDecl fd : pipe.forwardDecls) sb.append(CodeGen.generateNode(fd, 0));

for (var v : pipe.arrayResult.hoistedSizingConstants) sb.append(CodeGen.generateNode(v, 0));

java.util.Set<String> autoHoistedNames = new java.util.HashSet<>();

for (TopLevelItem av : pipe.autoHoisted) if (av instanceof VariableDecl avd) autoHoistedNames.add(avd.name());

for (var v : pipe.depResult.hoistedVariables) {

if (!autoHoistedNames.contains(v.name())) sb.append(CodeGen.generateNode(v, 0));

}

for (TypeDef td : pipe.finalClasses) sb.append(CodeGen.generateNode(td, 0));

for (TopLevelItem av : pipe.autoHoisted) sb.append(CodeGen.generateNode(av, 0));

for (var v : pipe.arrayResult.hoistedArrays) sb.append(CodeGen.generateNode(v, 0));

for (FunctionDecl fd : pipe.depResult.hoistedFunctions) sb.append(CodeGen.generateNode(fd, 0));

// Collect lifecycle bodies; remaining items go into _PSketch.

List<FunctionDecl> lifecycleBodies = new ArrayList<>();

List<TopLevelItem> sketchMembers = new ArrayList<>();

for (TopLevelItem item : effectiveRest) {

if (item instanceof FunctionDecl fd && fd.body() != null && LIFECYCLE.contains(fd.name())) {

lifecycleBodies.add(fd);

} else {

sketchMembers.add(item);

}

}

// Strip redundant forward decls (same as writeSketchImpl).

java.util.Set<String> definedFns = new java.util.HashSet<>();

for (TopLevelItem item : sketchMembers)

if (item instanceof FunctionDecl fd && fd.body() != null)

definedFns.add(fd.name() + "/" + fd.params().size());

sketchMembers.removeIf(item -> item instanceof FunctionDecl fd

&& fd.body() == null && !fd.isPureVirtual()

&& definedFns.contains(fd.name() + "/" + fd.params().size()));

// Hoist TopLevelStatements to namespace scope.

List<TopLevelItem> nsHoisted = new ArrayList<>(), realMembers = new ArrayList<>();

for (TopLevelItem item : sketchMembers) {

if (item instanceof TopLevelStatement) nsHoisted.add(item);

else realMembers.add(item);

}

for (TopLevelItem item : nsHoisted) sb.append(CodeGen.generateNode(item, 0));

// Build _PSketch with lifecycle methods inlined.

sb.append("class _PSketch : public PApplet {\npublic:\n");

for (TopLevelItem item : realMembers) sb.append(CodeGen.generateNode(item, 1));

Map<String,FunctionDecl> bodyMap = new LinkedHashMap<>();

for (FunctionDecl fd : lifecycleBodies) bodyMap.put(fd.name(), fd);

for (String name : LIFECYCLE) {

FunctionDecl fd = bodyMap.get(name);

if (fd == null) continue;

String rendered = CodeGen.generateNode(fd, 0).strip();

if (!rendered.contains("override"))

rendered = rendered.replaceFirst("(\\b" + name + "\\s*\\([^)]*\\)\\s*)", "$1 override ");

for (String line : rendered.split("\n", -1))

sb.append(" ").append(line).append("\n");

}

sb.append("};\n");

sb.append("\n} // namespace Processing\n");

return sb.toString();

}

/**

* Produces the full C++ source string for a sketch, including #line directives,

* for use by CppLinter (g++ -fsyntax-only).

*/

public static String translateForLint(String sketchCode) throws Exception {

CppBuild.PreparedCode prepared = CppBuild.prepareCode(sketchCode);

String code = prepared.code;

boolean hasSetup = code.contains("void setup(");

boolean hasDraw = code.contains("void draw(");

StringBuilder hasIncludePreNs = new StringBuilder();

for (String block : prepared.hasIncludeBlocks.values())

hasIncludePreNs.append(block);

StringBuilder preNs = new StringBuilder();

StringBuilder result = new StringBuilder();

if (hasSetup || hasDraw) {

String body = runPipeline(code, preNs);

result.append(hasIncludePreNs);

result.append(preNs);

result.append("#include \"Processing.h\"\n");

result.append("using namespace std;\n");

result.append(body);

} else {

result.append(hasIncludePreNs);

result.append(preNs);

result.append("#include \"Processing.h\"\n");

result.append("using namespace std;\n");

result.append("\nnamespace Processing {\n\n");

result.append(code);

result.append("\n} // namespace Processing\n");

}

return result.toString();

}

private static void appendHeader(StringBuilder out) {

out.append("#include \"Processing.h\"\n");

out.append("using namespace std;\n");

}

}