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, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (" name " *)instance; }"

    22

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

    23

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

    24

	print "	template <> const " name " &GetParam(ForceType<const " name " &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { 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

    31

	enum_string_to_error_size = 0

    32

	enum_error_to_string_size = 0

    33

	struct_size = 0

    34

	method_size = 0

    35

	static_method_size = 0

    36

	virtual_class = "false"

    37

	super_cls = ""

    38

	cls = ""

    39

	start_squirrel_define_on_next_line = "false"

    40

	cls_level = 0

    41

	RS = "\r|\n"

    42

}

    43

    44

/@file/ {

    45

	# Break it in two lines, so SVN doesn't replace it

    46

	printf "/* $I"

    47

	print "d$ */"

    48

	print "/* THIS FILE IS AUTO-GENERATED; PLEASE DO NOT ALTER MANUALLY */"

    49

	print ""

    50

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

    51

}

    52

    53

# Remove the old squirrel stuff

    54

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

    55

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

    56

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

    57

    58

# Ignore forward declarations of classes

    59

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

    60

# We only want to have public functions exported for now

    61

/^(	*)class/     {

    62

	if (cls_level == 0) {

    63

		public = "false"

    64

		cls_param[0] = ""

    65

		cls_param[1] = 1

    66

		cls_param[2] = "x"

    67

		cls = $2

    68

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

    69

			super_cls = $5

    70

		} else {

    71

			super_cls = $4

    72

		}

    73

	} else if (cls_level == 1) {

    74

		struct_size++

    75

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

    76

	}

    77

	cls_level++

    78

	next

    79

}

    80

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

    81

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

    82

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

    83

    84

# Ignore special doxygen blocks

    85

/^#ifndef DOXYGEN_SKIP/ { doxygen_skip = "next"; next; }

    86

/^#ifdef DOXYGEN_SKIP/  { doxygen_skip = "true"; next; }

    87

/^#endif/               { doxygen_skip = "false"; next; }

    88

/^#else/                {

    89

	if (doxygen_skip == "next") {

    90

		doxygen_skip = "true";

    91

	} else {

    92

		doxygen_skip = "false";

    93

	}

    94

	next;

    95

}

    96

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

    97

    98

# Ignore the comments

    99

/^#/             { next; }

   100

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

   101

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

   102

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

   103

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

   104

   105

# We need to make specialized conversions for structs

   106

/^(	*)struct/ {

   107

	cls_level++

   108

	if (public == "false") next

   109

	if (cls_level != 1) next

   110

	struct_size++

   111

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

   112

	next

   113

}

   114

   115

# We need to make specialized conversions for enums

   116

/^(	*)enum/ {

   117

	cls_level++

   118

	if (public == "false") next;

   119

	in_enum = "true"

   120

	enum_size++

   121

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

   122

	next

   123

}

   124

   125

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

   126

/};/ {

   127

	cls_level--

   128

	if (cls_level != 0) {

   129

		in_enum = "false";

   130

		next;

   131

	}

   132

	if (cls == "") {

   133

		next;

   134

	}

   135

	start_squirrel_define_on_next_line = "true"

   136

	next;

   137

}

   138

   139

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

   140

/^([ 	]*)$/ {

   141

	if (start_squirrel_define_on_next_line == "false") next

   142

	spaces = "                                                               ";

   143

	public = "false"

   144

	namespace_opened = "false"

   145

   146

	print ""

   147

   148

	# First check whether we have enums to print

   149

	if (enum_size != 0) {

   150

		if (namespace_opened == "false") {

   151

			print "namespace SQConvert {"

   152

			namespace_opened = "true"

   153

		}

   154

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

   155

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

   156

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

   157

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

   158

			delete enums[i]

   159

		}

   160

	}

   161

   162

	# Then check whether we have structs/classes to print

   163

	if (struct_size != 0) {

   164

		if (namespace_opened == "false") {

   165

			print "namespace SQConvert {"

   166

			namespace_opened = "true"

   167

		}

   168

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

   169

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

   170

			dump_class_templates(structs[i])

   171

			delete structs[i]

   172

		}

   173

	}

   174

   175

	if (namespace_opened == "false") {

   176

		print "namespace SQConvert {"

   177

		namespace_opened = "true"

   178

	} else {

   179

		print ""

   180

	}

   181

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

   182

	dump_class_templates(cls)

   183

   184

	print "}; // namespace SQConvert"

   185

   186

	print "";

   187

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

   188

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

   189

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

   190

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

   191

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

   192

	} else {

   193

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

   194

	}

   195

	if (virtual_class == "false" && super_cls != "AIEvent") {

   196

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

   197

	}

   198

	print ""

   199

   200

	# Enum values

   201

	mlen = 0

   202

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

   203

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

   204

	}

   205

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

   206

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

   207

		delete enum_value[i]

   208

	}

   209

	if (enum_value_size != 0) print ""

   210

   211

	# Mapping of OTTD strings to errors

   212

	mlen = 0

   213

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

   214

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

   215

	}

   216

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

   217

		print "	AIError::RegisterErrorMap(" enum_string_to_error_mapping_string[i] ", " substr(spaces, 1, mlen - length(enum_string_to_error_mapping_string[i]))  cls "::" enum_string_to_error_mapping_error[i] ");"

   218

   219

		delete enum_string_to_error_mapping_string[i]

   220

	}

   221

	if (enum_string_to_error_size != 0) print ""

   222

   223

	# Mapping of errors to human 'readable' strings.

   224

	mlen = 0

   225

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

   226

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

   227

	}

   228

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

   229

		print "	AIError::RegisterErrorMapString(" cls "::" enum_error_to_string_mapping[i] ", " substr(spaces, 1, mlen - length(enum_error_to_string_mapping[i])) "\"" enum_error_to_string_mapping[i] "\");"

   230

		delete enum_error_to_string_mapping[i]

   231

	}

   232

	if (enum_error_to_string_size != 0) print ""

   233

   234

	# Static methods

   235

	mlen = 0

   236

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

   237

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

   238

	}

   239

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

   240

		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] "\");"

   241

		delete static_methods[i]

   242

	}

   243

	if (static_method_size != 0) print ""

   244

   245

	if (virtual_class == "false") {

   246

		# Non-static methods

   247

		mlen = 0

   248

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

   249

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

   250

		}

   251

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

   252

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

   253

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

   254

			} else {

   255

				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] "\");"

   256

			}

   257

			delete methods[i]

   258

		}

   259

		if (method_size != 0) print ""

   260

	}

   261

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

   262

	print "}"

   263

   264

	enum_size = 0

   265

	enum_value_size = 0

   266

	enum_string_to_error_size = 0

   267

	enum_error_to_string_size = 0

   268

	struct_size = 0

   269

	method_size = 0

   270

	static_method_size = 0

   271

	virtual_class = "false"

   272

	cls = ""

   273

	start_squirrel_define_on_next_line = "false"

   274

	cls_level = 0

   275

}

   276

   277

# Skip non-public functions

   278

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

   279

   280

# Add enums

   281

{

   282

	if (in_enum == "true") {

   283

		enum_value_size++

   284

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

   285

		enum_value[enum_value_size] = $1

   286

   287

		# Check if this a special error enum

   288

		if (match(enums[enum_size], ".*::ErrorMessages") != 0) {

   289

			# syntax:

   290

			# enum ErrorMessages {

   291

			#	ERR_SOME_ERROR,	// [STR_ITEM1, STR_ITEM2, ...]

   292

			# }

   293

   294

			# Set the mappings

   295

			if (match($0, "\\[.*\\]") != 0) {

   296

				mappings = substr($0, RSTART, RLENGTH);

   297

				gsub("([\\[[:space:]\\]])", "", mappings);

   298

   299

				split(mappings, mapitems, ",");

   300

				for (i = 1; i <= length(mapitems); i++) {

   301

					enum_string_to_error_size++

   302

					enum_string_to_error_mapping_string[enum_string_to_error_size] = mapitems[i]

   303

					enum_string_to_error_mapping_error[enum_string_to_error_size] = $1

   304

				}

   305

   306

				enum_error_to_string_size++

   307

				enum_error_to_string_mapping[enum_error_to_string_size] = $1

   308

			}

   309

		}

   310

		next

   311

	}

   312

}

   313

   314

# Add a method to the list

   315

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

   316

	if (cls_level != 1) next

   317

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

   318

   319

	is_static = match($0, "static")

   320

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

   321

		virtual_class = "true"

   322

	}

   323

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

   324

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

   325

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

   326

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

   327

	param_s = $0

   328

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

   329

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

   330

   331

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

   332

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

   333

   334

	funcname = $2

   335

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

   336

		cls_param[0] = param_s

   337

		if (param_s == "") next

   338

	} else if (funcname == "") next

   339

   340

	split(param_s, params, ",")

   341

	types = "x"

   342

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

   343

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

   344

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

   345

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

   346

				types = types "s"

   347

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

   348

				types = types "p"

   349

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

   350

				types = types "a"

   351

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

   352

				types = types "a"

   353

			} else {

   354

				types = types "x"

   355

			}

   356

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

   357

			types = types "b"

   358

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

   359

			types = "v"

   360

		} else {

   361

			types = types "i"

   362

		}

   363

	}

   364

   365

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

   366

		cls_param[1] = len;

   367

		cls_param[2] = types;

   368

	} else if (is_static) {

   369

		static_method_size++

   370

		static_methods[static_method_size, 0] = funcname

   371

		static_methods[static_method_size, 1] = len

   372

		static_methods[static_method_size, 2] = types

   373

	} else {

   374

		method_size++

   375

		methods[method_size, 0] = funcname

   376

		methods[method_size, 1] = len

   377

		methods[method_size, 2] = types

   378

	}

   379

	next

   380

}