1

#

     2

# Awk script to automatically generate the code needed

     3

# to export the AI API to Squirrel.

     4

#

     5

# Note that arrays are 1 based...

     6

#

     7

     8

# Simple insertion sort.

     9

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

    10

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

    11

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

    12

			temp = ARRAY[j]

    13

			ARRAY[j] = ARRAY[j - 1]

    14

			ARRAY[j - 1] = temp

    15

	}

    16

	return

    17

}

    18

    19

function dump_class_templates(name) {

    20

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

    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 <> const " name " *GetParam(ForceType<const " 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 <> 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; }"

    25

}

    26

    27

BEGIN {

    28

	enum_size = 0

    29

	enum_value_size = 0

    30

	struct_size = 0

    31

	method_size = 0

    32

	static_method_size = 0

    33

	virtual_class = "false"

    34

	super_cls = ""

    35

	cls = ""

    36

	start_squirrel_define_on_next_line = "false"

    37

	cls_level = 0

    38

}

    39

    40

/@file/ {

    41

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

    42

}

    43

    44

# Remove the old squirrel stuff

    45

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

    46

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

    47

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

    48

    49

# Ignore forward declarations of classes

    50

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

    51

# We only want to have public functions exported for now

    52

/^(	*)class/     {

    53

	if (cls_level == 0) {

    54

		public = "false"

    55

		cls_param[0] = ""

    56

		cls_param[1] = 1

    57

		cls_param[2] = "x"

    58

		cls = $2

    59

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

    60

			super_cls = $5

    61

		} else {

    62

			super_cls = $4

    63

		}

    64

	} else if (cls_level == 1) {

    65

		struct_size++

    66

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

    67

	}

    68

	cls_level++

    69

	next

    70

}

    71

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

    72

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

    73

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

    74

    75

# Ignore the comments

    76

/^#/             { next; }

    77

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

    78

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

    79

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

    80

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

    81

    82

# We need to make specialized conversions for structs

    83

/^(	*)struct/ {

    84

	cls_level++

    85

	if (public == "false") next

    86

	if (cls_level != 1) next

    87

	struct_size++

    88

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

    89

	next

    90

}

    91

    92

# We need to make specialized conversions for enums

    93

/^(	*)enum/ {

    94

	cls_level++

    95

	if (public == "false") next;

    96

	in_enum = "true"

    97

	enum_size++

    98

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

    99

	next

   100

}

   101

   102

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

   103

/};/ {

   104

	cls_level--

   105

	if (cls_level != 0) {

   106

		in_enum = "false";

   107

		next;

   108

	}

   109

	if (cls == "") {

   110

		next;

   111

	}

   112

	start_squirrel_define_on_next_line = "true"

   113

	next;

   114

}

   115

   116

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

   117

/^([ 	]*)$/ {

   118

	if (start_squirrel_define_on_next_line == "false") next

   119

	spaces = "                                                               ";

   120

	public = "false"

   121

	namespace_opened = "false"

   122

   123

	print ""

   124

   125

	# First check whether we have enums to print

   126

	if (enum_size != 0) {

   127

		if (namespace_opened == "false") {

   128

			print "namespace SQConvert {"

   129

			namespace_opened = "true"

   130

		}

   131

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

   132

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

   133

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

   134

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

   135

			delete enums[i]

   136

		}

   137

	}

   138

   139

	# Then check whether we have structs/classes to print

   140

	if (struct_size != 0) {

   141

		if (namespace_opened == "false") {

   142

			print "namespace SQConvert {"

   143

			namespace_opened = "true"

   144

		}

   145

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

   146

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

   147

			dump_class_templates(structs[i])

   148

			delete structs[i]

   149

		}

   150

	}

   151

   152

	if (namespace_opened == "false") {

   153

		print "namespace SQConvert {"

   154

		namespace_opened = "true"

   155

	} else {

   156

		print ""

   157

	}

   158

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

   159

	dump_class_templates(cls)

   160

   161

	print "}; // namespace SQConvert"

   162

   163

	print "";

   164

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

   165

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

   166

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

   167

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

   168

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

   169

	} else {

   170

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

   171

	}

   172

	if (virtual_class == "false") {

   173

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

   174

	}

   175

	print ""

   176

   177

	# Enum values

   178

	mlen = 0

   179

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

   180

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

   181

	}

   182

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

   183

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

   184

		delete enum_value[i]

   185

	}

   186

	if (enum_value_size != 0) print ""

   187

   188

	# Static methods

   189

	mlen = 0

   190

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

   191

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

   192

	}

   193

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

   194

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

   195

		delete static_methods[i]

   196

	}

   197

	if (static_method_size != 0) print ""

   198

   199

	if (virtual_class == "false") {

   200

		# Non-static methods

   201

		mlen = 0

   202

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

   203

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

   204

		}

   205

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

   206

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

   207

			delete methods[i]

   208

		}

   209

		if (method_size != 0) print ""

   210

	}

   211

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

   212

	print "}"

   213

   214

	enum_size = 0

   215

	enum_value_size = 0

   216

	struct_size = 0

   217

	method_size = 0

   218

	static_method_size = 0

   219

	virtual_class = "false"

   220

	cls = ""

   221

	start_squirrel_define_on_next_line = "false"

   222

	cls_level = 0

   223

}

   224

   225

# Skip non-public functions

   226

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

   227

   228

# Add enums

   229

{

   230

	if (in_enum == "true") {

   231

		enum_value_size++

   232

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

   233

		enum_value[enum_value_size] = $1

   234

		next

   235

	}

   236

}

   237

   238

# Add a method to the list

   239

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

   240

	if (cls_level != 1) next

   241

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

   242

   243

	is_static = match($0, "static")

   244

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

   245

		virtual_class = "true"

   246

	}

   247

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

   248

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

   249

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

   250

	param_s = $0

   251

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

   252

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

   253

   254

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

   255

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

   256

   257

	funcname = $2

   258

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

   259

		cls_param[0] = param_s

   260

		if (param_s == "") next

   261

	} else if (funcname == "") next

   262

   263

	split(param_s, params, ",")

   264

	types = "x"

   265

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

   266

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

   267

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

   268

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

   269

				types = types "s"

   270

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

   271

				types = types "p"

   272

			} else {

   273

				types = types "x"

   274

			}

   275

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

   276

			types = types "b"

   277

		} else {

   278

			types = types "i"

   279

		}

   280

	}

   281

   282

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

   283

		cls_param[1] = len;

   284

		cls_param[2] = types;

   285

	} else if (is_static) {

   286

		static_method_size++

   287

		static_methods[static_method_size, 0] = funcname

   288

		static_methods[static_method_size, 1] = len

   289

		static_methods[static_method_size, 2] = types

   290

	} else {

   291

		method_size++

   292

		methods[method_size, 0] = funcname

   293

		methods[method_size, 1] = len

   294

		methods[method_size, 2] = types

   295

	}

   296

	next

   297

}