1

# $Id$

     2

#

     3

# Awk script to automatically generate the code needed

     4

# to export the AI API to Squirrel.

     5

#

     6

# Note that arrays are 1 based...

     7

#

     8

     9

# Simple insertion sort.

    10

function array_sort(ARRAY, ELEMENTS, temp, i, j) {

    11

	for (i = 2; i <= ELEMENTS; i++)

    12

		for (j = i; ARRAY[j - 1] > ARRAY[j]; --j) {

    13

			temp = ARRAY[j]

    14

			ARRAY[j] = ARRAY[j - 1]

    15

			ARRAY[j - 1] = temp

    16

	}

    17

	return

    18

}

    19

    20

function dump_class_templates(name) {

    21

	print "	template <> "       name " *GetParam(ForceType<"       name " *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (" name " *)instance; }"

    22

	print "	template <> "       name " &GetParam(ForceType<"       name " &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(" name " *)instance; }"

    23

	print "	template <> const " name " *GetParam(ForceType<const " name " *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (" name " *)instance; }"

    24

	print "	template <> const " name " &GetParam(ForceType<const " name " &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(" name " *)instance; }"

    25

	print "	template <> int Return<" name " *>(HSQUIRRELVM vm, " name " *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, \"" name "\", res, NULL, DefSQDestructorCallback<" name ">); return 1; }"

    26

}

    27

    28

BEGIN {

    29

	enum_size = 0

    30

	enum_value_size = 0

    32

	struct_size = 0

    33

	method_size = 0

    34

	static_method_size = 0

    35

	virtual_class = "false"

    36

	super_cls = ""

    37

	cls = ""

    38

	start_squirrel_define_on_next_line = "false"

    39

	cls_level = 0

    40

}

    41

    42

/@file/ {

    43

	print "#include \"" $3 "\""

    44

}

    45

    46

# Remove the old squirrel stuff

    47

/#ifdef DEFINE_SQUIRREL_CLASS/ { squirrel_stuff = "true";  next; }

    48

/^#endif \/\* DEFINE_SQUIRREL_CLASS \*\// { if (squirrel_stuff == "true") { squirrel_stuff = "false"; next; } }

    49

{ if (squirrel_stuff == "true") next; }

    50

    51

# Ignore forward declarations of classes

    52

/^(	*)class(.*);/ { next; }

    53

# We only want to have public functions exported for now

    54

/^(	*)class/     {

    55

	if (cls_level == 0) {

    56

		public = "false"

    57

		cls_param[0] = ""

    58

		cls_param[1] = 1

    59

		cls_param[2] = "x"

    60

		cls = $2

    61

		if (match($4, "public") || match($4, "protected") || match($4, "private")) {

    62

			super_cls = $5

    63

		} else {

    64

			super_cls = $4

    65

		}

    66

	} else if (cls_level == 1) {

    67

		struct_size++

    68

		structs[struct_size] = cls "::" $2

    69

	}

    70

	cls_level++

    71

	next

    72

}

    73

/^(	*)public/    { if (cls_level == 1) public = "true";  next; }

    74

/^(	*)protected/ { if (cls_level == 1) public = "false"; next; }

    75

/^(	*)private/   { if (cls_level == 1) public = "false"; next; }

    76

    77

# Ignore the comments

    78

/^#/             { next; }

    79

/\/\*.*\*\//     { comment = "false"; next; }

    80

/\/\*/           { comment = "true";  next; }

    81

/\*\//           { comment = "false"; next; }

    82

{ if (comment == "true") next }

    83

    84

# We need to make specialized conversions for structs

    85

/^(	*)struct/ {

    86

	cls_level++

    87

	if (public == "false") next

    88

	if (cls_level != 1) next

    89

	struct_size++

    90

	structs[struct_size] = cls "::" $2

    91

	next

    92

}

    93

    94

# We need to make specialized conversions for enums

    95

/^(	*)enum/ {

    96

	cls_level++

    97

	if (public == "false") next;

    98

	in_enum = "true"

    99

	enum_size++

   100

	enums[enum_size] = cls "::" $2

   101

	next

   102

}

   103

   104

# Maybe the end of the class, if so we can start with the Squirrel export pretty soon

   105

/};/ {

   106

	cls_level--

   107

	if (cls_level != 0) {

   108

		in_enum = "false";

   109

		next;

   110

	}

   111

	if (cls == "") {

   112

		next;

   113

	}

   114

	start_squirrel_define_on_next_line = "true"

   115

	next;

   116

}

   117

   118

# Empty/white lines. When we may do the Squirrel export, do that export.

   119

/^([ 	]*)$/ {

   120

	if (start_squirrel_define_on_next_line == "false") next

   121

	spaces = "                                                               ";

   122

	public = "false"

   123

	namespace_opened = "false"

   124

   125

	print ""

   126

   127

	# First check whether we have enums to print

   128

	if (enum_size != 0) {

   129

		if (namespace_opened == "false") {

   130

			print "namespace SQConvert {"

   131

			namespace_opened = "true"

   132

		}

   133

		print "	/* Allow enums to be used as Squirrel parameters */"

   134

		for (i = 1; i <= enum_size; i++) {

   135

			print "	template <> " enums[i] " GetParam(ForceType<" enums[i] ">, HSQUIRRELVM vm, int index) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (" enums[i] ")tmp; }"

   136

			print "	template <> int Return<" enums[i] ">(HSQUIRRELVM vm, " enums[i] " res) { sq_pushinteger(vm, (int32)res); return 1; }"

   137

			delete enums[i]

   138

		}

   139

	}

   140

   141

	# Then check whether we have structs/classes to print

   142

	if (struct_size != 0) {

   143

		if (namespace_opened == "false") {

   144

			print "namespace SQConvert {"

   145

			namespace_opened = "true"

   146

		}

   147

		print "	/* Allow inner classes/structs to be used as Squirrel parameters */"

   148

		for (i = 1; i <= struct_size; i++) {

   149

			dump_class_templates(structs[i])

   150

			delete structs[i]

   151

		}

   152

	}

   153

   154

	if (namespace_opened == "false") {

   155

		print "namespace SQConvert {"

   156

		namespace_opened = "true"

   157

	} else {

   158

		print ""

   159

	}

   160

	print "	/* Allow " cls " to be used as Squirrel parameter */"

   161

	dump_class_templates(cls)

   162

   163

	print "}; // namespace SQConvert"

   164

   165

	print "";

   166

	# Then do the registration functions of the class. */

   167

	print "void SQ" cls "_Register(Squirrel *engine) {"

   168

	print "	DefSQClass <" cls "> SQ" cls "(\"" cls "\");"

   169

	if (super_cls == "AIObject" || super_cls == "AIAbstractList::Valuator") {

   170

		print "	SQ" cls ".PreRegister(engine);"

   171

	} else {

   172

		print "	SQ" cls ".PreRegister(engine, \"" super_cls "\");"

   173

	}

   174

	if (virtual_class == "false") {

   175

		print "	SQ" cls ".AddConstructor<void (" cls "::*)(" cls_param[0] "), " cls_param[1]">(engine, \"" cls_param[2] "\");"

   176

	}

   177

	print ""

   178

   179

	# Enum values

   180

	mlen = 0

   181

	for (i = 1; i <= enum_value_size; i++) {

   182

		if (mlen <= length(enum_value[i])) mlen = length(enum_value[i])

   183

	}

   184

	for (i = 1; i <= enum_value_size; i++) {

   185

		print "	SQ" cls ".DefSQConst(engine, " cls "::" enum_value[i] ", " substr(spaces, 1, mlen - length(enum_value[i])) "\""  enum_value[i] "\");"

   186

		delete enum_value[i]

   187

	}

   188

	if (enum_value_size != 0) print ""

   189

   203

	# Static methods

   204

	mlen = 0

   205

	for (i = 1; i <= static_method_size; i++) {

   206

		if (mlen <= length(static_methods[i, 0])) mlen = length(static_methods[i, 0])

   207

	}

   208

	for (i = 1; i <= static_method_size; i++) {

   209

		print "	SQ" cls ".DefSQStaticMethod(engine, &" cls "::" static_methods[i, 0] ", " substr(spaces, 1, mlen - length(static_methods[i, 0])) "\""  static_methods[i, 0] "\", " substr(spaces, 1, mlen - length(static_methods[i, 0])) "" static_methods[i, 1] ", \"" static_methods[i, 2] "\");"

   210

		delete static_methods[i]

   211

	}

   212

	if (static_method_size != 0) print ""

   213

   214

	if (virtual_class == "false") {

   215

		# Non-static methods

   216

		mlen = 0

   217

		for (i = 1; i <= method_size; i++) {

   218

			if (mlen <= length(methods[i, 0])) mlen = length(methods[i, 0])

   219

		}

   220

		for (i = 1; i <= method_size; i++) {

   221

			if (methods[i, 2] == "v") {

   222

				print "	SQ" cls ".DefSQAdvancedMethod(engine, &" cls "::" methods[i, 0] ", " substr(spaces, 1, mlen - length(methods[i, 0]) - 8) "\""  methods[i, 0] "\");"

   223

			} else {

   224

				print "	SQ" cls ".DefSQMethod(engine, &" cls "::" methods[i, 0] ", " substr(spaces, 1, mlen - length(methods[i, 0])) "\""  methods[i, 0] "\", " substr(spaces, 1, mlen - length(methods[i, 0])) "" methods[i, 1] ", \"" methods[i, 2] "\");"

   225

			}

   226

			delete methods[i]

   227

		}

   228

		if (method_size != 0) print ""

   229

	}

   230

	print "	SQ" cls ".PostRegister(engine);"

   231

	print "}"

   232

   233

	enum_size = 0

   234

	enum_value_size = 0

   236

	struct_size = 0

   237

	method_size = 0

   238

	static_method_size = 0

   239

	virtual_class = "false"

   240

	cls = ""

   241

	start_squirrel_define_on_next_line = "false"

   242

	cls_level = 0

   243

}

   244

   245

# Skip non-public functions

   246

{ if (public == "false") next }

   247

   248

# Add enums

   249

{

   250

	if (in_enum == "true") {

   251

		enum_value_size++

   252

		sub(",", "", $1)

   253

		enum_value[enum_value_size] = $1

   278

		next

   279

	}

   280

}

   281

   282

# Add a method to the list

   283

/^.*\(.*\).*$/ {

   284

	if (cls_level != 1) next

   285

	if (match($0, "~")) next

   286

   287

	is_static = match($0, "static")

   288

	if (match($0, "virtual")) {

   289

		virtual_class = "true"

   290

	}

   291

	gsub("virtual", "", $0)

   292

	gsub("static", "", $0)

   293

	gsub("const", "", $0)

   294

	gsub("{.*", "", $0)

   295

	param_s = $0

   296

	gsub("\\*", "", $0)

   297

	gsub("\\(.*", "", $0)

   298

   299

	sub(".*\\(", "", param_s)

   300

	sub("\\).*", "", param_s)

   301

   302

	funcname = $2

   303

	if ($1 == cls && funcname == "") {

   304

		cls_param[0] = param_s

   305

		if (param_s == "") next

   306

	} else if (funcname == "") next

   307

   308

	split(param_s, params, ",")

   309

	types = "x"

   310

	for (len = 1; params[len] != ""; len++) {

   311

		sub("^[ 	]*", "", params[len])

   312

		if (match(params[len], "\\*") || match(params[len], "&")) {

   313

			if (match(params[len], "^char")) {

   314

				types = types "s"

   315

			} else if (match(params[len], "^void")) {

   316

				types = types "p"

   317

			} else {

   318

				types = types "x"

   319

			}

   320

		} else if (match(params[len], "^bool")) {

   321

			types = types "b"

   322

		} else if (match(params[len], "^HSQUIRRELVM")) {

   323

			types = "v"

   324

		} else {

   325

			types = types "i"

   326

		}

   327

	}

   328

   329

	if ($1 == cls && funcname == "") {

   330

		cls_param[1] = len;

   331

		cls_param[2] = types;

   332

	} else if (is_static) {

   333

		static_method_size++

   334

		static_methods[static_method_size, 0] = funcname

   335

		static_methods[static_method_size, 1] = len

   336

		static_methods[static_method_size, 2] = types

   337

	} else {

   338

		method_size++

   339

		methods[method_size, 0] = funcname

   340

		methods[method_size, 1] = len

   341

		methods[method_size, 2] = types

   342

	}

   343

	next

   344

}