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) {

    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 the comments

    85

/^#/             { next; }

    86

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

    87

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

    88

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

    89

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

    90

    91

# We need to make specialized conversions for structs

    92

/^(	*)struct/ {

    93

	cls_level++

    94

	if (public == "false") next

    95

	if (cls_level != 1) next

    96

	struct_size++

    97

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

    98

	next

    99

}

   100

   101

# We need to make specialized conversions for enums

   102

/^(	*)enum/ {

   103

	cls_level++

   104

	if (public == "false") next;

   105

	in_enum = "true"

   106

	enum_size++

   107

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

   108

	next

   109

}

   110

   111

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

   112

/};/ {

   113

	cls_level--

   114

	if (cls_level != 0) {

   115

		in_enum = "false";

   116

		next;

   117

	}

   118

	if (cls == "") {

   119

		next;

   120

	}

   121

	start_squirrel_define_on_next_line = "true"

   122

	next;

   123

}

   124

   125

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

   126

/^([ 	]*)$/ {

   127

	if (start_squirrel_define_on_next_line == "false") next

   128

	spaces = "                                                               ";

   129

	public = "false"

   130

	namespace_opened = "false"

   131

   132

	print ""

   133

   134

	# First check whether we have enums to print

   135

	if (enum_size != 0) {

   136

		if (namespace_opened == "false") {

   137

			print "namespace SQConvert {"

   138

			namespace_opened = "true"

   139

		}

   140

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

   141

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

   143

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

   144

			delete enums[i]

   145

		}

   146

	}

   147

   148

	# Then check whether we have structs/classes to print

   149

	if (struct_size != 0) {

   150

		if (namespace_opened == "false") {

   151

			print "namespace SQConvert {"

   152

			namespace_opened = "true"

   153

		}

   154

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

   155

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

   156

			dump_class_templates(structs[i])

   157

			delete structs[i]

   158

		}

   159

	}

   160

   161

	if (namespace_opened == "false") {

   162

		print "namespace SQConvert {"

   163

		namespace_opened = "true"

   164

	} else {

   165

		print ""

   166

	}

   167

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

   168

	dump_class_templates(cls)

   169

   170

	print "}; // namespace SQConvert"

   171

   172

	print "";

   173

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

   174

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

   175

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

   176

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

   177

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

   178

	} else {

   179

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

   180

	}

   181

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

   182

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

   183

	}

   184

	print ""

   185

   186

	# Enum values

   187

	mlen = 0

   188

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

   189

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

   190

	}

   191

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

   192

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

   193

		delete enum_value[i]

   194

	}

   195

	if (enum_value_size != 0) print ""

   196

   197

	# Mapping of OTTD strings to errors

   198

	mlen = 0

   199

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

   200

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

   201

	}

   202

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

   203

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

   204

   205

		delete enum_string_to_error_mapping_string[i]

   206

	}

   207

	if (enum_string_to_error_size != 0) print ""

   208

   209

	# Mapping of errors to human 'readable' strings.

   210

	mlen = 0

   211

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

   212

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

   213

	}

   214

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

   215

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

   216

		delete enum_error_to_string_mapping[i]

   217

	}

   218

	if (enum_error_to_string_size != 0) print ""

   219

   220

	# Static methods

   221

	mlen = 0

   222

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

   223

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

   224

	}

   225

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

   226

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

   227

		delete static_methods[i]

   228

	}

   229

	if (static_method_size != 0) print ""

   230

   231

	if (virtual_class == "false") {

   232

		# Non-static methods

   233

		mlen = 0

   234

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

   235

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

   236

		}

   237

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

   238

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

   239

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

   240

			} else {

   241

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

   242

			}

   243

			delete methods[i]

   244

		}

   245

		if (method_size != 0) print ""

   246

	}

   247

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

   248

	print "}"

   249

   250

	enum_size = 0

   251

	enum_value_size = 0

   252

	enum_string_to_error_size = 0

   253

	enum_error_to_string_size = 0

   254

	struct_size = 0

   255

	method_size = 0

   256

	static_method_size = 0

   257

	virtual_class = "false"

   258

	cls = ""

   259

	start_squirrel_define_on_next_line = "false"

   260

	cls_level = 0

   261

}

   262

   263

# Skip non-public functions

   264

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

   265

   266

# Add enums

   267

{

   268

	if (in_enum == "true") {

   269

		enum_value_size++

   270

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

   271

		enum_value[enum_value_size] = $1

   272

   273

		# Check if this a special error enum

   274

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

   275

			# syntax:

   276

			# enum ErrorMessages {

   277

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

   278

			# }

   279

   280

			# Set the mappings

   281

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

   282

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

   283

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

   284

   285

				split(mappings, mapitems, ",");

   286

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

   287

					enum_string_to_error_size++

   288

					enum_string_to_error_mapping_string[enum_string_to_error_size] = mapitems[i]

   289

					enum_string_to_error_mapping_error[enum_string_to_error_size] = $1

   290

				}

   291

   292

				enum_error_to_string_size++

   293

				enum_error_to_string_mapping[enum_error_to_string_size] = $1

   294

			}

   295

		}

   296

		next

   297

	}

   298

}

   299

   300

# Add a method to the list

   301

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

   302

	if (cls_level != 1) next

   303

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

   304

   305

	is_static = match($0, "static")

   306

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

   307

		virtual_class = "true"

   308

	}

   309

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

   310

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

   311

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

   312

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

   313

	param_s = $0

   314

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

   315

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

   316

   317

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

   318

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

   319

   320

	funcname = $2

   321

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

   322

		cls_param[0] = param_s

   323

		if (param_s == "") next

   324

	} else if (funcname == "") next

   325

   326

	split(param_s, params, ",")

   327

	types = "x"

   328

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

   329

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

   330

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

   331

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

   332

				types = types "s"

   333

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

   334

				types = types "p"

   335

			} else {

   336

				types = types "x"

   337

			}

   338

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

   339

			types = types "b"

   340

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

   341

			types = "v"

   342

		} else {

   343

			types = types "i"

   344

		}

   345

	}

   346

   347

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

   348

		cls_param[1] = len;

   349

		cls_param[2] = types;

   350

	} else if (is_static) {

   351

		static_method_size++

   352

		static_methods[static_method_size, 0] = funcname

   353

		static_methods[static_method_size, 1] = len

   354

		static_methods[static_method_size, 2] = types

   355

	} else {

   356

		method_size++

   357

		methods[method_size, 0] = funcname

   358

		methods[method_size, 1] = len

   359

		methods[method_size, 2] = types

   360

	}

   361

	next

   362

}