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"

    55

		cls = $2

    56

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

    57

			super_cls = $5

    58

		} else {

    59

			super_cls = $4

    60

		}

    61

	} else if (cls_level == 1) {

    62

		struct_size++

    63

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

    64

	}

    65

	cls_level++

    66

	next

    67

}

    68

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

    69

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

    70

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

    71

    72

# Ignore the comments

    73

/^#/             { next; }

    74

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

    75

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

    76

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

    77

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

    78

    79

# We need to make specialized conversions for structs

    80

/^(	*)struct/ {

    81

	cls_level++

    82

	if (public == "false") next

    83

	if (cls_level != 1) next

    84

	struct_size++

    85

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

    86

	next

    87

}

    88

    89

# We need to make specialized conversions for enums

    90

/^(	*)enum/ {

    91

	cls_level++

    92

	if (public == "false") next;

    93

	in_enum = "true"

    94

	enum_size++

    95

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

    96

	next

    97

}

    98

    99

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

   100

/};/ {

   101

	cls_level--

   102

	if (cls_level != 0) {

   103

		in_enum = "false";

   104

		next;

   105

	}

   106

	if (cls == "") {

   107

		next;

   108

	}

   109

	start_squirrel_define_on_next_line = "true"

   110

	next;

   111

}

   112

   113

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

   114

/^([ 	]*)$/ {

   115

	if (start_squirrel_define_on_next_line == "false") next

   116

	spaces = "                                                               ";

   117

	public = "false"

   118

	namespace_opened = "false"

   119

   120

	print ""

   121

   122

	# First check whether we have enums to print

   123

	if (enum_size != 0) {

   124

		if (namespace_opened == "false") {

   125

			print "namespace SQConvert {"

   126

			namespace_opened = "true"

   127

		}

   128

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

   129

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

   130

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

   131

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

   132

			delete enums[i]

   133

		}

   134

	}

   135

   136

	# Then check whether we have structs/classes to print

   137

	if (struct_size != 0) {

   138

		if (namespace_opened == "false") {

   139

			print "namespace SQConvert {"

   140

			namespace_opened = "true"

   141

		}

   142

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

   143

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

   144

			dump_class_templates(structs[i])

   145

			delete structs[i]

   146

		}

   147

	}

   148

   149

	if (namespace_opened == "false") {

   150

		print "namespace SQConvert {"

   151

		namespace_opened = "true"

   152

	} else {

   153

		print ""

   154

	}

   155

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

   156

	dump_class_templates(cls)

   157

   158

	print "}; // namespace SQConvert"

   159

   160

	if (virtual_class == "false") {

   161

		print "";

   162

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

   163

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

   164

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

   165

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

   166

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

   167

		} else {

   168

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

   169

		}

   171

		print ""

   172

   173

		# Enum values

   174

		mlen = 0

   175

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

   176

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

   177

		}

   178

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

   179

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

   180

			delete enum_value[i]

   181

		}

   182

		if (enum_value_size != 0) print ""

   183

   184

		# Static methods

   185

		mlen = 0

   186

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

   187

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

   188

		}

   189

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

   190

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

   191

			delete static_methods[i]

   192

		}

   193

		if (static_method_size != 0) print ""

   194

   195

		# Non-static methods

   196

		mlen = 0

   197

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

   198

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

   199

		}

   200

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

   201

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

   202

			delete methods[i]

   203

		}

   204

		if (method_size != 0) print ""

   205

   206

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

   207

		print "}"

   208

	}

   209

   210

	enum_size = 0

   211

	enum_value_size = 0

   212

	struct_size = 0

   213

	method_size = 0

   214

	static_method_size = 0

   215

	virtual_class = "false"

   216

	cls = ""

   217

	start_squirrel_define_on_next_line = "false"

   218

	cls_level = 0

   219

}

   220

   221

# Skip non-public functions

   222

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

   223

   224

# Add enums

   225

{

   226

	if (in_enum == "true") {

   227

		enum_value_size++

   228

		enum_value[enum_value_size] = $1

   229

		next

   230

	}

   231

}

   232

   233

# Add a method to the list

   234

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

   235

	if (cls_level != 1) next

   236

   237

	is_static = match($0, "static")

   238

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

   239

		virtual_class = "true"

   240

	}

   241

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

   242

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

   243

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

   244

	param_s = $0

   245

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

   246

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

   247

   248

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

   249

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

   250

   258

	split(param_s, params, ",")

   259

	types = "x"

   260

	len = 1;

   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

   276

	if (is_static) {

   277

		static_method_size++

   278

		static_methods[static_method_size, 0] = funcname

   279

		static_methods[static_method_size, 1] = len

   280

		static_methods[static_method_size, 2] = types

   281

	} else {

   282

		method_size++

   283

		methods[method_size, 0] = funcname

   284

		methods[method_size, 1] = len

   285

		methods[method_size, 2] = types

   286

	}

   287

	next

   288

}