Skip to content

Commit

Permalink
refactor: fix typos
Browse files Browse the repository at this point in the history
  • Loading branch information
Brian West committed Apr 23, 2021
1 parent 24fc48d commit de6312e
Show file tree
Hide file tree
Showing 6 changed files with 69 additions and 69 deletions.
2 changes: 1 addition & 1 deletion SCsub
View file
Original file line number Diff line number Diff line change
Expand Up @@ -57,7 +57,7 @@ sources = [

if env['tools']:
with open_file("tools/godot.d.ts.gen.cpp", "w") as f:
text = '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString ECMAScriptPlugin::BUILTIN_DECLEARATION_TEXT = \n${source};';
text = '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString ECMAScriptPlugin::BUILTIN_DECLARATION_TEXT = \n${source};'
f.write(text.replace('${source}', dump_text_file_to_cpp("misc/godot.d.ts")))
with open_file("tools/tsconfig.json.gen.cpp", "w") as f:
text = '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString ECMAScriptPlugin::TSCONFIG_CONTENT = \n${source};'
Expand Down
6 changes: 3 additions & 3 deletions generate_builtin_api.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -331,7 +331,7 @@
]
}

def apply_parttern(template, values):
def apply_pattern(template, values):
for key in values:
template = template.replace( '${' + key + '}', values[key])
return template
Expand Down Expand Up @@ -405,15 +405,15 @@ def parse_class(cls):
if class_name in IGNORED_PROPS and const_name in IGNORED_PROPS[class_name]:
continue
constants.append(dict(c.attrib))
return json.loads(apply_parttern(json.dumps(ret), {
return json.loads(apply_pattern(json.dumps(ret), {
'class_name': class_name,
}))

def generate_api_json(MODULE_DIR):
DOCS_DIR = os.path.abspath(os.path.join(MODULE_DIR, "../../doc/classes"))
if not os.path.isdir(DOCS_DIR) and len(sys.argv) > 1:
DOCS_DIR = sys.argv[-1]
OUTPUT_FILE = os.path.join(MODULE_DIR, "buitin_api.gen.json");
OUTPUT_FILE = os.path.join(MODULE_DIR, "builtin_api.gen.json")

classes = []
for cls in BUILTIN_CLASSES:
Expand Down
88 changes: 44 additions & 44 deletions quickjs/builtin_binding_generator.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,7 +3,7 @@

DIR = os.path.abspath( os.path.dirname(__file__) )
OUTPUT_FILE = os.path.join(DIR, "quickjs_builtin_binder.gen.cpp")
API = json.load(open(os.path.join(DIR, '..', 'buitin_api.gen.json'), 'r'))
API = json.load(open(os.path.join(DIR, '..', 'builtin_api.gen.json'), 'r'))

VariantTypes = {
"boolean": "Variant::BOOL",
Expand Down Expand Up @@ -104,7 +104,7 @@
"Variant": 'QuickJSBinder::variant_to_var(ctx, ${arg})',
}

def apply_parttern(template, values):
def apply_pattern(template, values):
for key in values:
template = template.replace( '${' + key + '}', values[key])
return template
Expand Down Expand Up @@ -411,22 +411,22 @@ def generate_constructor(cls):
}
}
''',
"PoolByteArray": apply_parttern(TemplatePoolArrays, {"class": "PoolByteArray", "type": "Variant::POOL_BYTE_ARRAY", "element": "uint8_t"}),
"PoolIntArray": apply_parttern(TemplatePoolArrays, {"class": "PoolIntArray", "type": "Variant::POOL_INT_ARRAY", "element": "int"}),
"PoolRealArray": apply_parttern(TemplatePoolArrays, {"class": "PoolRealArray", "type": "Variant::POOL_REAL_ARRAY", "element": "real_t"}),
"PoolVector2Array": apply_parttern(TemplatePoolArrays, {"class": "PoolVector2Array", "type": "Variant::POOL_VECTOR2_ARRAY", "element": "Vector2"}),
"PoolVector3Array": apply_parttern(TemplatePoolArrays, {"class": "PoolVector3Array", "type": "Variant::POOL_VECTOR3_ARRAY", "element": "Vector3"}),
"PoolColorArray": apply_parttern(TemplatePoolArrays, {"class": "PoolColorArray", "type": "Variant::POOL_COLOR_ARRAY", "element": "Color"}),
"PoolStringArray": apply_parttern(TemplateSimplePoolArrays,{"class": "PoolStringArray", "type": "Variant::POOL_STRING_ARRAY", "element": "String"}),
"PoolByteArray": apply_pattern(TemplatePoolArrays, {"class": "PoolByteArray", "type": "Variant::POOL_BYTE_ARRAY", "element": "uint8_t"}),
"PoolIntArray": apply_pattern(TemplatePoolArrays, {"class": "PoolIntArray", "type": "Variant::POOL_INT_ARRAY", "element": "int"}),
"PoolRealArray": apply_pattern(TemplatePoolArrays, {"class": "PoolRealArray", "type": "Variant::POOL_REAL_ARRAY", "element": "real_t"}),
"PoolVector2Array": apply_pattern(TemplatePoolArrays, {"class": "PoolVector2Array", "type": "Variant::POOL_VECTOR2_ARRAY", "element": "Vector2"}),
"PoolVector3Array": apply_pattern(TemplatePoolArrays, {"class": "PoolVector3Array", "type": "Variant::POOL_VECTOR3_ARRAY", "element": "Vector3"}),
"PoolColorArray": apply_pattern(TemplatePoolArrays, {"class": "PoolColorArray", "type": "Variant::POOL_COLOR_ARRAY", "element": "Color"}),
"PoolStringArray": apply_pattern(TemplateSimplePoolArrays,{"class": "PoolStringArray", "type": "Variant::POOL_STRING_ARRAY", "element": "String"}),
}
class_name = cls['name']
constructor_name = apply_parttern(TemplateConstructorName, {"class": class_name})
constructor_declare = apply_parttern(TemplateConstructorDeclare, {"class": class_name})
constructor_name = apply_pattern(TemplateConstructorName, {"class": class_name})
constructor_declare = apply_pattern(TemplateConstructorDeclare, {"class": class_name})

initializer = ''
if class_name in ConstructorInitializers:
initializer = ConstructorInitializers[class_name]
consturctor = apply_parttern(TemplateConstructor, {
consturctor = apply_pattern(TemplateConstructor, {
'class': class_name,
'type': VariantTypes[class_name],
'func': constructor_name,
Expand Down Expand Up @@ -479,21 +479,21 @@ def generate_members(cls):
type = p['type']
name = p['name']
native_name = p['native']
getters += apply_parttern(TemplateGetterItem, {
getters += apply_pattern(TemplateGetterItem, {
'index': str(i),
'value': apply_parttern(GodotToJSTemplates[type], { 'arg': apply_parttern('ptr->${native}', {'native': native_name}) })
'value': apply_pattern(GodotToJSTemplates[type], { 'arg': apply_pattern('ptr->${native}', {'native': native_name}) })
})
setters += apply_parttern(TemplateSetterItem, {
setters += apply_pattern(TemplateSetterItem, {
'index': str(i),
'name': name,
'native': native_name,
'type': VariantTypes[type],
'type_name': type,
'class': class_name,
'value': apply_parttern(JSToGodotTemplates[type], {'arg': 'argv[0]'})
'value': apply_pattern(JSToGodotTemplates[type], {'arg': 'argv[0]'})
})
bindings += apply_parttern(TemplateItemBinding, {'index': str(i), 'name': name, 'type': VariantTypes[class_name]})
return apply_parttern(Template, {
bindings += apply_pattern(TemplateItemBinding, {'index': str(i), 'name': name, 'type': VariantTypes[class_name]})
return apply_pattern(Template, {
'class': class_name,
'getters': getters,
'setters': setters,
Expand All @@ -509,12 +509,12 @@ def generate_methods(cls):
[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
${class} *ptr = bind->get${class}();\
${arg_declars}
${arg_declares}
${call}
return ${return};
},
${argc});'''
TemplateArgDeclear = '''
TemplateArgDeclare = '''
#ifdef DEBUG_METHODS_ENABLED
ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, ${type}, argv[${index}]), (JS_ThrowTypeError(ctx, "${type_name} expected for argument ${index} of ${class}.${name}")));
#endif
Expand All @@ -524,39 +524,39 @@ def generate_methods(cls):
bindings = ''
for m in cls['methods']:
args = ''
arg_declars = ''
arg_declares = ''
for i in range(len(m['arguments'])):
arg = m['arguments'][i]
arg_type = arg['type']
arg_declars += apply_parttern(TemplateArgDeclear, {
arg_declares += apply_pattern(TemplateArgDeclare, {
'index': str(i),
'type': VariantTypes[arg_type],
'type_name': arg_type,
'class': class_name,
'name': m['name'],
'arg': apply_parttern(JSToGodotTemplates[arg_type], {'arg': 'argv[' + str(i) +']'}),
'arg': apply_pattern(JSToGodotTemplates[arg_type], {'arg': 'argv[' + str(i) +']'}),
'godot_type': GodotTypeNames[arg_type],
})
if i > 0: args += ', '
args += 'arg' + str(i)
CallTemplate = ('' if m['return'] == 'void' else (apply_parttern(TemplateReturnValue, {"godot_type": GodotTypeNames[m['return']]}))) + 'ptr->${native_method}(${args});'
call = apply_parttern(CallTemplate, {'native_method': m['native_method'], 'args': args})
bindings += apply_parttern(TemplateMethod, {
CallTemplate = ('' if m['return'] == 'void' else (apply_pattern(TemplateReturnValue, {"godot_type": GodotTypeNames[m['return']]}))) + 'ptr->${native_method}(${args});'
call = apply_pattern(CallTemplate, {'native_method': m['native_method'], 'args': args})
bindings += apply_pattern(TemplateMethod, {
"class": class_name,
"type": VariantTypes[class_name],
"name": m['name'],
"call": call,
"arg_declars": arg_declars,
"arg_declares": arg_declares,
"argc": str(len(m['arguments'])),
"return": 'JS_UNDEFINED' if m['return'] == 'void' else apply_parttern(GodotToJSTemplates[m['return']], {'arg': 'ret'}),
"return": 'JS_UNDEFINED' if m['return'] == 'void' else apply_pattern(GodotToJSTemplates[m['return']], {'arg': 'ret'}),
})
return bindings

def generate_constants(cls):
ConstTemplate = '\tbinder->get_builtin_binder().register_constant(${type}, "${name}", ${value});\n'
bindings = ''
for c in cls['constants']:
bindings += apply_parttern(ConstTemplate, {
bindings += apply_pattern(ConstTemplate, {
"name": c['name'],
"type": VariantTypes[class_name],
"value": c['value']
Expand All @@ -572,7 +572,7 @@ def genertate_operators(cls):
'operator==': '==',
'operator<': '<'
}
TargetDeclearTemplate = '''
TargetDeclareTemplate = '''
#ifdef DEBUG_METHODS_ENABLED
ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, ${type}, argv[1]), (JS_ThrowTypeError(ctx, "${target_class} expected for ${class}.${operator}")));
#endif
Expand All @@ -584,7 +584,7 @@ def genertate_operators(cls):
JS_NewCFunction(ctx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
${class} *ptr = bind->get${class}();\
${target_declear}
${target_declare}
${call}
return ${return};
},
Expand All @@ -607,29 +607,29 @@ def genertate_operators(cls):
js_op = 'neg'

args = ''
target_declear = ''
target_declare = ''
if argc > 1:
arg_class = o['arguments'][0]['type']
target_declear = apply_parttern(TargetDeclearTemplate, {
target_declare = apply_pattern(TargetDeclareTemplate, {
'target_class': arg_class,
'type': VariantTypes[arg_class],
'class': class_name,
'operator': o['native_method'],
})
args = '*target'
CallTemplate = ('' if o['return'] == 'void' else apply_parttern(TemplateReturnValue, {'godot_type': GodotTypeNames[o['return']] })) + 'ptr->${op}(${args});'
call = apply_parttern(CallTemplate, {'op': op, 'args': args})
bindings += apply_parttern(OperatorTemplate, {
CallTemplate = ('' if o['return'] == 'void' else apply_pattern(TemplateReturnValue, {'godot_type': GodotTypeNames[o['return']] })) + 'ptr->${op}(${args});'
call = apply_pattern(CallTemplate, {'op': op, 'args': args})
bindings += apply_pattern(OperatorTemplate, {
'type': VariantTypes[class_name],
'class': class_name,
'js_op': js_op,
'call': call,
'name': o['name'],
'target_declear': target_declear,
"return": 'JS_UNDEFINED' if o['return'] == 'void' else apply_parttern(GodotToJSTemplates[o['return']], {'arg': 'ret'}),
'target_declare': target_declare,
"return": 'JS_UNDEFINED' if o['return'] == 'void' else apply_pattern(GodotToJSTemplates[o['return']], {'arg': 'ret'}),
'argc': str(argc)
})
bindings += apply_parttern('''
bindings += apply_pattern('''
operators.push_back(base_operators);
binder->get_builtin_binder().get_cross_type_operators(${type}, operators);
binder->get_builtin_binder().register_operators(${type}, operators);
Expand All @@ -646,21 +646,21 @@ def genertate_operators(cls):
}
'''
class_name = cls['name']
property_declare = apply_parttern(TemplateDeclar, {"class": class_name})
property_defines = apply_parttern(TemplateBindDefine, {
property_declare = apply_pattern(TemplateDeclar, {"class": class_name})
property_defines = apply_pattern(TemplateBindDefine, {
"class": class_name,
"members": generate_members(cls) if len(cls['properties']) else '',
"methods": generate_methods(cls),
"constants": generate_constants(cls),
"operators": genertate_operators(cls),
})
property_bind = apply_parttern(TemplateBind, {"class": class_name})
property_bind = apply_pattern(TemplateBind, {"class": class_name})
return property_declare, property_defines, property_bind


def generate_class_bind_action(cls, constructor):
Template = '\tregister_builtin_class(${type}, "${class}", ${constructor}, ${argc});\n'
return apply_parttern(Template, {
return apply_pattern(Template, {
'class': cls['name'],
'constructor': constructor,
'type': VariantTypes[cls['name']],
Expand Down Expand Up @@ -703,7 +703,7 @@ def generate_builtin_bindings():
definitions += property_defines
bindings += property_bind

output = apply_parttern(Template, {
output = apply_pattern(Template, {
'declarations': declarations,
'bindings': bindings,
'definitions': definitions,
Expand Down
2 changes: 1 addition & 1 deletion quickjs/quickjs_binder.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1153,7 +1153,7 @@ void QuickJSBinder::add_godot_globals() {
}
}

// buitin functions
// builtin functions
for (int i = 0; i < Expression::FUNC_MAX; ++i) {
Expression::BuiltinFunc func = (Expression::BuiltinFunc)i;
String name = Expression::get_func_name(func);
Expand Down
Loading

0 comments on commit de6312e

Please sign in to comment.