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

}

    25

    26

BEGIN {

    27

	enum_size = 0

    28

	enum_value_size = 0

    29

	struct_size = 0

    30

	method_size = 0

    31

	static_method_size = 0

    32

	virtual_class = "false"

    33

	super_cls = ""

    34

	cls = ""

    35

	start_squirrel_define_on_next_line = "false"

    36

	cls_level = 0

    37

}

    38

    39

/@file/ {

    40

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

    41

}

    42

    43

# Remove the old squirrel stuff

    44

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

    45

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

    46

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

    47

    48

# Ignore forward declarations of classes

    49

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

    50

# We only want to have public functions exported for now

    51

/^(	*)class/     {

    52

	if (cls_level == 0) {

    53

		public = "false"

    57

		cls = $2

    58

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

    59

			super_cls = $5

    60

		} else {

    61

			super_cls = $4

    62

		}

    63

	} else if (cls_level == 1) {

    64

		struct_size++

    65

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

    66

	}

    67

	cls_level++

    68

	next

    69

}

    70

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

    71

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

    72

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

    73

    74

# Ignore the comments

    75

/^#/             { next; }

    76

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

    77

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

    78

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

    79

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

    80

    81

# We need to make specialized conversions for structs

    82

/^(	*)struct/ {

    83

	cls_level++

    84

	if (public == "false") next

    85

	if (cls_level != 1) next

    86

	struct_size++

    87

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

    88

	next

    89

}

    90

    91

# We need to make specialized conversions for enums

    92

/^(	*)enum/ {

    93

	cls_level++

    94

	if (public == "false") next;

    95

	in_enum = "true"

    96

	enum_size++

    97

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

    98

	next

    99

}

   100

   101

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

   102

/};/ {

   103

	cls_level--

   104

	if (cls_level != 0) {

   105

		in_enum = "false";

   106

		next;

   107

	}

   108

	if (cls == "") {

   109

		next;

   110

	}

   111

	start_squirrel_define_on_next_line = "true"

   112

	next;

   113

}

   114

   115

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

   116

/^([ 	]*)$/ {

   117

	if (start_squirrel_define_on_next_line == "false") next

   118

	spaces = "                                                               ";

   119

	public = "false"

   120

	namespace_opened = "false"

   121

   122

	print ""

   123

   124

	# First check whether we have enums to print

   125

	if (enum_size != 0) {

   126

		if (namespace_opened == "false") {

   127

			print "namespace SQConvert {"

   128

			namespace_opened = "true"

   129

		}

   130

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

   131

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

   132

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

   133

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

   134

			delete enums[i]

   135

		}

   136

	}

   137

   138

	# Then check whether we have structs/classes to print

   139

	if (struct_size != 0) {

   140

		if (namespace_opened == "false") {

   141

			print "namespace SQConvert {"

   142

			namespace_opened = "true"

   143

		}

   144

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

   145

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

   146

			dump_class_templates(structs[i])

   147

			delete structs[i]

   148

		}

   149

	}

   150

   151

	if (namespace_opened == "false") {

   152

		print "namespace SQConvert {"

   153

		namespace_opened = "true"

   154

	} else {

   155

		print ""

   156

	}

   157

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

   158

	dump_class_templates(cls)

   159

   160

	print "}; // namespace SQConvert"

   161

   162

	if (virtual_class == "false") {

   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

		}

   173

		print ""

   174

   175

		# Enum values

   176

		mlen = 0

   177

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

   178

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

   179

		}

   180

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

   181

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

   182

			delete enum_value[i]

   183

		}

   184

		if (enum_value_size != 0) print ""

   185

   186

		# Static methods

   187

		mlen = 0

   188

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

   189

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

   190

		}

   191

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

   192

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

   193

			delete static_methods[i]

   194

		}

   195

		if (static_method_size != 0) print ""

   196

   197

		# Non-static methods

   198

		mlen = 0

   199

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

   200

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

   201

		}

   202

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

   203

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

   204

			delete methods[i]

   205

		}

   206

		if (method_size != 0) print ""

   207

   208

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

   209

		print "}"

   210

	}

   211

   212

	enum_size = 0

   213

	enum_value_size = 0

   214

	struct_size = 0

   215

	method_size = 0

   216

	static_method_size = 0

   217

	virtual_class = "false"

   218

	cls = ""

   219

	start_squirrel_define_on_next_line = "false"

   220

	cls_level = 0

   221

}

   222

   223

# Skip non-public functions

   224

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

   225

   226

# Add enums

   227

{

   228

	if (in_enum == "true") {

   229

		enum_value_size++

   230

		enum_value[enum_value_size] = $1

   231

		next

   232

	}

   233

}

   234

   235

# Add a method to the list

   236

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

   237

	if (cls_level != 1) next

   238

   239

	is_static = match($0, "static")

   240

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

   241

		virtual_class = "true"

   242

	}

   243

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

   244

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

   245

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

   246

	param_s = $0

   247

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

   248

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

   249

   250

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

   251

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

   252

   253

	funcname = $2

   254

	if ($1 == cls) {

   258

   259

	split(param_s, params, ",")

   260

	types = "x"

   261

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

   262

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

   263

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

   264

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

   265

				types = types "s"

   266

			} else {

   267

				types = types "x"

   268

			}

   269

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

   270

			types = types "b"

   271

		} else {

   272

			types = types "i"

   273

		}

   274

	}

   275

   280

		static_method_size++

   281

		static_methods[static_method_size, 0] = funcname

   282

		static_methods[static_method_size, 1] = len

   283

		static_methods[static_method_size, 2] = types

   284

	} else {

   285

		method_size++

   286

		methods[method_size, 0] = funcname

   287

		methods[method_size, 1] = len

   288

		methods[method_size, 2] = types

   289

	}

   290

	next

   291

}