/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 */

package org.opensolaris.os.adr.adrgen;

import org.opensolaris.os.adr.*;

public class CGenerator {

    private static final String DOMAIN = "C";

    private static final String NULLSTR = "NULL";

    private static void setTargetName(Type t, String name) {

	t.setAuxData(DOMAIN, name);

    }

    private static String getTargetName(Type t) {

	return (String)t.getAuxData(DOMAIN);

    }

    private static String toBoolean(boolean b) {

	return b ? "B_TRUE" : "B_FALSE";

    }

    private static String toErrorPtr(Type error) {

	if (error == null)

	    return NULLSTR;

	return String.format("&t_%s", getTargetName(error));

    }

    static String toStabilityStr(Stability s) {

	switch (s) {

	    case PRIVATE:

		return "s_private";

	    case UNCOMMITTED:

		return "s_uncommitted";

	    case COMMITTED:

		return "s_committed";

	    default:

		throw new AssertionError("Invalid Stability: " + s);

	}

    }

    static void generateVersions(PrintStream impl, API api) {

	APIVersion v = api.getVersionByStability(Stability.PRIVATE);

	impl.format("    { { %s, %d, %d },", toStabilityStr(Stability.PRIVATE),

	    v.getMajor(), v.getMinor());

	v = api.getVersionByStability(Stability.UNCOMMITTED);

	impl.format(" { %s, %d, %d },", toStabilityStr(Stability.UNCOMMITTED),

	    v.getMajor(), v.getMinor());

	v = api.getVersionByStability(Stability.COMMITTED);

	impl.format(" { %s, %d, %d } },\n", toStabilityStr(Stability.COMMITTED),

	    v.getMajor(), v.getMinor());

    }

    static void generateComplex(PrintStream header, PrintStream impl,

	Type.ComplexType t) {

	String tn = getTargetName(t);

	String fn = "t_fields_" + tn;

	impl.format("static typefield_t %s[] = {\n", fn);

	List<Field> fields = t.getAllFields();

	for (Field f : fields)

	    impl.format("    { \"%s\", &t_%s, %s },\n", f.getName(),

		getTargetName(f.getType()), toBoolean(f.isOptional()));

	impl.format("};\n");

	header.format("extern type_t t_%s;\n", tn);

	impl.format(

	    "type_t t_%s = { dt_struct, \"%s\", %d, { .t_fields = %s } };\n",

	    tn, t.getName() == null ? "(anon)" : t.getName(),

	    fields.size(), fn);

	impl.println();

    }

    static void generateUnion(PrintStream header, PrintStream impl,

	Type.UnionType t) {

	String tn = getTargetName(t);

	String dn = getTargetName(t.getDiscType());

	String fn = "t_arms_" + tn;

	boolean bool = t.getDiscType() == Type.getType(StdType.BOOLEAN);

	Arm defaultarm = t.getDefault();

	impl.format("static unionarm_t %s[] = {\n", fn);

	if (defaultarm != null) {

		impl.format("    { NULL, &t_%s, %s },\n",

		    getTargetName(defaultarm.getType()),

		    toBoolean(defaultarm.isOptional()));

	} else {

		impl.format("    { NULL, NULL, B_FALSE },\n");

	}

	if (bool) {

	    for (Arm a : t.getArms())

		impl.format("    { &d_%s, &t_%s, %s },\n",

		    (Boolean)a.getDiscValue() ? "true" : "false",

		    getTargetName(a.getType()), toBoolean(a.isOptional()));

	} else {

	    for (Arm a : t.getArms())

		impl.format("    { &e_%s_%s, &t_%s, %s },\n",

		    dn, ((Type.EnumValue)a.getDiscValue()).getName(),

		    getTargetName(a.getType()), toBoolean(a.isOptional()));

	}

	impl.format("};\n");

	header.format("extern type_t t_%s;\n", tn);

	impl.format(

	    "type_t t_%s = { dt_union, \"%s\", %d, \n" +

	    "    { .t_union = { &t_%s, %s } }\n" +

	    "};\n", tn, t.getName(), t.getArms().size(), dn, fn);

	impl.println();

    }

    static void generateArray(PrintStream header, PrintStream impl,

	Type.ArrayType t) {

	String tn = getTargetName(t);

	header.format("extern type_t t_%s;\n", tn);

	impl.format(

	    "type_t t_%s = { dt_array, \"%s\", 0, { .t_array = &t_%s } };\n",

	    tn, "(array)", getTargetName(t.getType()));

	impl.println();

    }

    static void generateEnum(PrintStream header, PrintStream impl,

	Type.EnumType t) {

	String tn = getTargetName(t);

	String fn = "t_values_" + tn;

	impl.format("static enumval_t %s[] = {\n", fn);

	Type.EnumValue fallback = t.getFallback();

	List<Type.EnumValue> vlist = t.getValues();

	if (fallback != null) {

	    vlist = new LinkedList<Type.EnumValue>(vlist);

	    vlist.add(0, fallback);

	} else {

	    impl.format("    { NULL, %d, NULL },\n", 0);

	}

	for (Type.EnumValue v : vlist)

	    impl.format("    { \"%s\", %d, &e_%s_%s },\n",

		v.getName(), v.getValue(), tn, v.getName());

	impl.format("};\n");

	header.format("extern type_t t_%s;\n", tn);

	impl.format(

	    "type_t t_%s = { dt_enum, \"%s\", %d, { .t_enum = %s } };\n",

	    tn, t.getName(), t.getValues().size(), fn);

	impl.println();

	int i = fallback == null ? 1 : 0;

	for (Type.EnumValue v : vlist) {

	    String en = String.format("e_%s_%s", tn, v.getName());

	    header.format("extern data_t %s;\n", en);

	    impl.format(

		"data_t %s = { &t_%s, 0, 0, 0, 0, { .integer = %d } };\n",

		en, tn, i++);

	}

	impl.println();

    }

	boolean common) throws FileNotFoundException {

	Interface iface = p.iface_;

	String header_name = "api_" + p.basename_ + ".h";

	for (Type.BuiltinType t : Type.BUILTINS.values())

	    setTargetName(t, t.getType().toString().toLowerCase());

	for (Type.ArrayType t : Type.BUILTIN_ARRAYS.values())

	    setTargetName(t, "array_" + getTargetName(t.getType()));

	for (Type.ComplexType t : iface.getTypes())

	    setTargetName(t, "_" + t.getName());

	for (Type.UnionType t : iface.getUnions())

	    setTargetName(t, "_" + t.getName());

	for (Type.EnumType t : iface.getEnums())

	    setTargetName(t, "_" + t.getName());

	for (Type.ArrayType t : iface.getArrays())

	    setTargetName(t, "array_" + getTargetName(t.getType()));

	o_header.format("#include <rad/adr.h>\n\n");

	o_header.format("#include <rad/adr_object.h>\n\n");

	if (server)

	    o_header.format("#include <rad/rad_modapi.h>\n");

	o_impl.format("#include \"" + header_name + "\"\n\n");

	o_impl.format("/* LINTLIBRARY */\n\n");

	o_impl.format("#define\tCOUNT(x)\t(sizeof (x) / sizeof (x[0]))\n\n");

	for (Type t : iface.getAll()) {

	    if (t instanceof Type.ComplexType) {

		generateComplex(o_header, o_impl, (Type.ComplexType)t);

	    } else if (t instanceof Type.ArrayType) {

		generateArray(o_header, o_impl, (Type.ArrayType)t);

	    } else if (t instanceof Type.EnumType) {

		generateEnum(o_header, o_impl, (Type.EnumType)t);

	    } else if (t instanceof Type.UnionType) {

		generateUnion(o_header, o_impl, (Type.UnionType)t);

	    }

	}

	/* All server routines, used when generating stubs */

	List<String> invokers = new LinkedList<String>();

	List<String> readers = new LinkedList<String>();

	List<String> writers = new LinkedList<String>();

	/*

	 * API naming conventions

	 *

	 * Functions:

	 * api_name_read_aname

	 * api_name_write_aname

	 * api_name_invoke_mname

	 *

	 * Types:

	 * adr_attribute_t api_name_attribute_aname

	 * adr_attribute_t *api_name_attributes[]

	 *

	 * parameter_t api_name_params_mname[]

	 * adr_method_t api_name_method_mname

	 * adr_method_t *api_name_methods[]

	 *

	 * (Below isn't an array of pointers, no api_name_event_ename)

	 * eventtype_t api_name_events[]

	 *

	 * Parents:

	 * adr_object_t *api_name_parents[];

	 *

	 * adr_object_t api_name

	 * rad_object_t api_name_svr

	 */

	/* XXX: need to require api/feature names be "tame". */

	/* XXX: Should keep readers/writers/invokers sorted */

	    List<String> myinvokers = new LinkedList<String>();

	    List<String> myreaders = new LinkedList<String>();

	    List<String> mywriters = new LinkedList<String>();

	    /*

	     * First, define attributes

	     */

	    List<String> myprops = new LinkedList<String>();

	    for (Property prop : api.getAllProps().values()) {

		String writefunc = NULLSTR;

		String readfunc = writefunc;

		boolean mine = common ? prop.getAPI() == api : true;

		String apiname = mine ? api.getName() : prop.getAPI().getName();

		if (server && prop.isWritable()) {

		    writefunc = String.format("api_%s_write_%s",

			apiname, prop.getName());

		    mywriters.add(writefunc);

		    if (mine) {

			o_header.format("attr_write_f %s;\n", writefunc);

			writers.add(writefunc);

			writefunc = "&" + writefunc;

		    }

		} else {

		    mywriters.add(null);

		}

		if (server && prop.isReadable()) {

		    readfunc = String.format("api_%s_read_%s",

			apiname, prop.getName());

		    myreaders.add(readfunc);

		    if (mine) {

			o_header.format("attr_read_f %s;\n", readfunc);

			readers.add(readfunc);

			readfunc = "&" + readfunc;

		    }

		} else {

		    myreaders.add(null);

		}

		if (mine) {

		    o_impl.format(

			"static adr_attribute_t api_%s_attribute_%s = {\n",

			apiname, prop.getName());

		    o_impl.format("    \"%s\", %s, &t_%s, %s,\n" +

			"    %s, %s, %s, %s\n",

			prop.getName(),

			toStabilityStr(prop.getStability()),

			getTargetName(prop.getType()),

			toErrorPtr(prop.getReadErrorType()),

			toErrorPtr(prop.getWriteErrorType()),

			toBoolean(prop.isOptional()),

			toBoolean(prop.isReadable()),

			toBoolean(prop.isWritable()));

		    o_impl.format("};\n\n");

		}

		myprops.add(String.format("api_%s_attribute_%s",

		    apiname, prop.getName()));

	    }

	    if (server && mywriters.size() > 0) {

		o_impl.format("static attr_write_t api_%s_write[] = {\n",

		    api.getName());

		for (String writer : mywriters) {

		    if (writer == null)

			o_impl.format("    NULL,\n");

		    else

			o_impl.format("    &%s,\n", writer);

		}

		o_impl.format("};\n");

	    }

	    if (server && myreaders.size() > 0) {

		o_impl.format("static attr_read_t api_%s_read[] = {\n",

		    api.getName());

		for (String reader : myreaders) {

		    if (reader == null)

			o_impl.format("    NULL,\n");

		    else

			o_impl.format("    &%s,\n", reader);

		}

		o_impl.format("};\n");

	    }

	    String nattributes = "0";

	    String attributes = NULLSTR;

	    if (myprops.size() > 0) {

		attributes = String.format("api_%s_attributes", api.getName());

		nattributes = String.format("COUNT(%s)", attributes);

		o_impl.format("static adr_attribute_t *%s[] = {\n", attributes);

		for (String prop : myprops)

		    o_impl.format("    &%s,\n", prop);

		o_impl.format("};\n\n");

	    }

	    /*

	     * Second define methods

	     */

	    List<String> mymethods = new LinkedList<String>();

	    for (Method method : api.getAllMethods().values()) {

		boolean mine = common ? method.getAPI() == api : true;

		String apiname = mine ? api.getName() :

		    method.getAPI().getName();

		String mfunc = String.format("api_%s_invoke_%s",

		    apiname, method.getName());

		myinvokers.add(mfunc);

		if (mine) {

		    if (server)

			o_header.format("meth_invoke_f %s;\n", mfunc);

		    String paramname = NULLSTR;

		    if (method.getArguments().size() > 0) {

			paramname = String.format("api_%s_params_%s",

			    apiname, method.getName());

			o_impl.format("static adr_parameter_t %s[] = {\n",

			    paramname);

			for (Argument arg : method.getArguments())

			    o_impl.format("    { \"%s\", &t_%s, %s },\n",

				arg.getName(), getTargetName(arg.getType()),

				toBoolean(arg.isOptional()));

			o_impl.format("};\n");

		    }

		    o_impl.format("static adr_method_t api_%s_method_%s = {\n",

			apiname, method.getName());

		    o_impl.format(

			"    \"%s\", %s, %d, &t_%s, %s,\n    %s, %s\n",

			method.getName(),

			toStabilityStr(method.getStability()),

			method.getArguments().size(),

			getTargetName(method.getResult().getType()),

			toErrorPtr(method.getErrorType()),

			toBoolean(method.getResult().isOptional()), paramname);

		    o_impl.format("};\n\n");

		    invokers.add(mfunc);

		}

		mymethods.add(String.format("api_%s_method_%s",

		    apiname, method.getName()));

	    }

	    if (server && myinvokers.size() > 0) {

		o_impl.format("static meth_invoke_t api_%s_invoke[] = {\n",

		    api.getName());

		for (String invoker : myinvokers)

		    o_impl.format("    &%s,\n", invoker);

		o_impl.format("};\n");

	    }

	    String nmethods = "0";

	    String methods = NULLSTR;

	    if (mymethods.size() > 0) {

		methods = String.format("api_%s_methods", api.getName());

		nmethods = String.format("COUNT(%s)", methods);

		o_impl.format("static adr_method_t *%s[] = {\n", methods);

		for (String method : mymethods)

		    o_impl.format("    &%s,\n", method);

		o_impl.format("};\n\n");

	    }

	    /*

	     * Third define events

	     */

	    String nevents = "0";

	    String events = NULLSTR;

	    if (api.getAllEvents().size() > 0) {

		events = String.format("api_%s_events", api.getName());

		nevents = String.format("COUNT(%s)", events);

		o_impl.format("static adr_event_t %s[] = {\n", events);

		for (Event event : api.getAllEvents().values())

		    o_impl.format("    { \"%s\", %s, &t_%s },\n",

			event.getName(),

			toStabilityStr(event.getStability()),

			getTargetName(event.getType()));

		o_impl.format("};\n\n");

	    }

	    /*

	     * Fourth define parents

	     */

	    String nparents = "0";

	    String parents = NULLSTR;

	    if (api.getParents().size() > 0) {

		parents = String.format("api_%s_parents", api.getName());

		nparents = String.format("COUNT(%s)", parents);

		o_impl.format("static adr_object_t *%s[] = {\n", parents);

		for (API papi : api.getParents())

		    o_impl.format("    &api_%s,\n", papi.getName());

		o_impl.format("};\n\n");

	    }

	    /*

	     * Last, define api

	     */

	    o_header.format("extern adr_object_t api_%s;\n", api.getName());

	    o_impl.format("adr_object_t api_%s = {\n", api.getName());

	    o_impl.format("    \"%s\",\n", iface.getName());

	    o_impl.format("    \"%s\",\n", api.getName());

	    generateVersions(o_impl, api);

	    o_impl.format("    %s,\n", nattributes);

	    o_impl.format("    %s,\n", nmethods);

	    o_impl.format("    %s,\n", nevents);

	    o_impl.format("    %s,\n", nparents);

	    o_impl.format("    %s,\n", attributes);

	    o_impl.format("    %s,\n", methods);

	    o_impl.format("    %s,\n", events);

	    o_impl.format("    %s\n", parents);

	    o_impl.format("};\n\n");

	    if (server) {

		o_header.format("extern rad_object_t api_%s_svr;\n",

		    api.getName());

		o_impl.format("rad_object_t api_%s_svr = {\n", api.getName());

		o_impl.format("    &api_%s,\n", api.getName());

		if (myinvokers.size() > 0)

		    o_impl.format("    api_%s_invoke,\n", api.getName());