static void create_text_node(lua_State *L, const GumboText *text) {
lua_createtable(L, 0, 5);
add_string(L, "text", text->text);
add_integer(L, "line", text->start_pos.line);
add_integer(L, "column", text->start_pos.column);
add_integer(L, "offset", text->start_pos.offset);
}
static void push_node(lua_State *L, const GumboNode *node) {
luaL_checkstack(L, 10, "element nesting too deep");
switch (node->type) {
case GUMBO_NODE_DOCUMENT: {
const GumboDocument *document = &node->v.document;
lua_createtable(L, document->children.length, 4);
add_literal(L, "type", "document");
add_string(L, "quirks_mode", quirksmap[document->doc_type_quirks_mode]);
if (document->has_doctype) {
lua_createtable(L, 0, 3);
add_string(L, "name", document->name);
add_string(L, "publicId", document->public_identifier);
add_string(L, "systemId", document->system_identifier);
lua_setfield(L, -2, "doctype");
}
add_children(L, &document->children);
return;
}
case GUMBO_NODE_ELEMENT: {
const GumboElement *element = &node->v.element;
lua_createtable(L, element->children.length, 7);
lua_getfield(L, LUA_REGISTRYINDEX, "gumbo.element");
lua_setmetatable(L, -2);
add_tag(L, element);
add_string(L, "tag_namespace", tagnsmap[element->tag_namespace]);
add_integer(L, "line", element->start_pos.line);
add_integer(L, "column", element->start_pos.column);
add_integer(L, "offset", element->start_pos.offset);
add_parseflags(L, node->parse_flags);
add_attributes(L, &element->attributes);
add_children(L, &element->children);
return;
}
case GUMBO_NODE_TEXT:
create_text_node(L, &node->v.text);
add_literal(L, "type", "text");
return;
case GUMBO_NODE_COMMENT:
create_text_node(L, &node->v.text);
add_literal(L, "type", "comment");
return;
case GUMBO_NODE_CDATA:
create_text_node(L, &node->v.text);
add_literal(L, "type", "cdata");
return;
case GUMBO_NODE_WHITESPACE:
create_text_node(L, &node->v.text);
add_literal(L, "type", "whitespace");
return;
}
}
static int test_init(){
lont r ;
printk(KERN_ALERT "test init\n");
if(1==addOrSub)
r = add_integer(a,b);
else
r = sub_integer(a,b);
printk(KERN_ALERT "the result is %ld\n",result);
return 0;
}
static void add_attributes(lua_State *L, const GumboVector *attrs) {
const unsigned int length = attrs->length;
if (length > 0) {
lua_createtable(L, length, length);
for (unsigned int i = 0; i < length; i++) {
const GumboAttribute *attr = (const GumboAttribute *)attrs->data[i];
add_string(L, attr->name, attr->value);
lua_createtable(L, 0, 6);
add_string(L, "name", attr->name);
add_string(L, "value", attr->value);
add_integer(L, "line", attr->name_start.line);
add_integer(L, "column", attr->name_start.column);
add_integer(L, "offset", attr->name_start.offset);
if (attr->attr_namespace != GUMBO_ATTR_NAMESPACE_NONE)
add_string(L, "namespace", attrnsmap[attr->attr_namespace]);
lua_rawseti(L, -2, i+1);
}
lua_setfield(L, -2, "attr");
}
}
/**
* Replaces the array elements.
*
* @param p0 the destination array
* @param p1 the source elements
* @param p2 the source elements count
* @param p3 the destination array index
* @param p4 the primitive abstraction
*/
void replace_array(void* p0, void* p1, void* p2, void* p3, void* p4) {
if (p2 != *NULL_POINTER_MEMORY_MODEL) {
int* sc = (int*) p2;
if (p0 != *NULL_POINTER_MEMORY_MODEL) {
log_terminated_message((void*) DEBUG_LEVEL_LOG_MODEL, (void*) L"Replace array elements.");
// The destination offset.
int dos = *NUMBER_0_INTEGER_MEMORY_MODEL;
// Determine abstraction (type) size.
determine_size((void*) &dos, p4);
// Calculate memory area (destination offset).
multiply_with_integer((void*) &dos, p3, (void*) INTEGER_PRIMITIVE_MEMORY_ABSTRACTION);
// The destination.
// CAUTION! It HAS TO BE initialised with p0,
// since an offset is added to it below.
void* d = p0;
// Add offset to destination.
add_integer((void*) &d, (void*) &dos, (void*) POINTER_PRIMITIVE_MEMORY_ABSTRACTION);
// The loop variable.
int j = *NUMBER_0_INTEGER_MEMORY_MODEL;
while (*NUMBER_1_INTEGER_MEMORY_MODEL) {
if (j >= *sc) {
break;
}
assign_with_offset(d, p1, (void*) &j, p4);
j++;
}
} else {
log_terminated_message((void*) ERROR_LEVEL_LOG_MODEL, (void*) L"Could not replace array elements. The array is null.");
}
} else {
log_terminated_message((void*) ERROR_LEVEL_LOG_MODEL, (void*) L"Could not replace array elements. The elements count is null.");
}
}
integer string_to_integer(char* s) {
integer result = create_integer((int)ceil(LOG_2_10*strlen(s)/COMPONENT_BITS));
set_zero_integer(result);
integer digit = create_integer(1);
int i;
for (i = 0; s[i] != '\0'; i++) {
multiply_small_integer(result, 10, result);
digit.c[0] = s[i] - '0';
add_integer(result, digit, result);
}
free_integer(digit);
return result;
}
int problem263()
{
integer testnum = string_to_integer("5");
integer testnum_helper = string_to_integer("5");
integer two = string_to_integer("2");
integer total_src = string_to_integer("0");
integer total_tar = string_to_integer("0");
integer target_dif = string_to_integer("6");
integer dif = string_to_integer("0");
int found = 0;
integer lastprime = string_to_integer("5");
//int sexy_count = 0;
printf("text here\n");
while (found < 4) {
//printf("gets 1\n");
if (miller_rabin(testnum) == PRIME) {
subtract_integer(testnum, lastprime, dif);
if (compare_integers(dif, target_dif) == 0) {
printf("difference between %s and %s is six\n",
integer_to_string(testnum), integer_to_string(lastprime));
found++;
}else {
found = 1;
}
copy_integer(testnum, lastprime);
add_integer(total_src, testnum, total_tar);
copy_integer(total_tar, total_src);
printf("Total is %s\n", integer_to_string(total_tar));
}
add_integer(testnum_helper, two, testnum);
copy_integer(testnum, testnum_helper);
printf("Tested %s\n", integer_to_string(testnum));
}
return 0;
}
void mod_integer(integer left, integer right, integer result) {
integer mod_two_power = create_integer(right.num_components + 1);
int i, bit;
set_zero_integer(result);
set_zero_integer(mod_two_power);
mod_two_power.c[0] = 1;
for(i=0; i<left.num_components; i++) {
for(bit=0; bit<COMPONENT_BITS; bit++) {
if ((left.c[i] & (1 << bit)) != 0) {
add_integer(result, mod_two_power, result);
if (compare_integers(result, right) >= 0) {
subtract_integer(result, right, result);
}
}
shift_left_one_integer(mod_two_power);
if (compare_integers(mod_two_power, right) >= 0) {
subtract_integer(mod_two_power, right, mod_two_power);
}
}
}
free_integer(mod_two_power);
}
integer hex_to_integer(unsigned char* data, unsigned int datalenBytes, unsigned int pad){
integer base=string_to_integer("256");
int siz=datalenBytes;
integer radix=create_integer(siz);
set_zero_integer(radix);
radix.c[0]=1;
integer result=create_integer(siz*2+pad);
set_zero_integer(result);
integer digit=create_integer(1);
for(int i=datalenBytes-1; i>=0; i--){
digit.c[0]=data[i];
integer part_res=create_integer(1+radix.num_components+1);
set_zero_integer(part_res);
multiply_integer(digit,radix,part_res);
add_integer(result,part_res,result);
free_integer(part_res);
integer radix_temp=create_integer(radix.num_components);
copy_integer(radix,radix_temp);
multiply_integer(radix_temp,base,radix);
free_integer(radix_temp);
}
optimize_integer(result);
return result;
}
#ifndef HAVE_PROJECTM2
add_loadfile( "projectm-config", "/usr/share/projectM/config.inp",
CONFIG_TEXT, CONFIG_LONGTEXT, true )
#else
#ifdef WIN32
add_directory( "projectm-preset-path", NULL,
#else
add_directory( "projectm-preset-path", "/usr/share/projectM/presets",
#endif
PRESET_PATH_TXT, PRESET_PATH_LONGTXT, true )
add_loadfile( "projectm-title-font", FONT_PATH,
TITLE_FONT_TXT, TITLE_FONT_LONGTXT, true )
add_loadfile( "projectm-menu-font", FONT_PATH_MENU,
MENU_FONT_TXT, MENU_FONT_LONGTXT, true )
#endif
add_integer( "projectm-width", 800, WIDTH_TEXT, WIDTH_LONGTEXT,
false )
add_integer( "projectm-height", 640, HEIGHT_TEXT, HEIGHT_LONGTEXT,
false )
add_integer( "projectm-meshx", 32, MESHX_TEXT, MESHX_LONGTEXT,
false )
add_integer( "projectm-meshy", 24, MESHY_TEXT, MESHY_LONGTEXT,
false )
add_integer( "projectm-texture-size", 1024, TEXTURE_TEXT, TEXTURE_LONGTEXT,
false )
add_shortcut( "projectm" )
set_callbacks( Open, Close )
vlc_module_end ()
/*****************************************************************************
* Local prototypes
static int hello_init(void)
{
int res = add_integer(1,3);
printk(KERN_WARNING "Hello, World! res=%d\n",res);
return 0;
}
int pow_mod(unsigned char** result,unsigned char* p,unsigned char* q, unsigned char* r,unsigned int keyLengthBytes){
std::set_new_handler(newh);
Array<integer> factors;
integer div=hex_to_integer(q,keyLengthBytes,0);
int siz=keyLengthBytes;
integer power_of_two=create_integer(siz);
set_zero_integer(power_of_two);
integer zero=create_integer(1);
set_zero_integer(zero);
integer two=string_to_integer("2");
integer one=string_to_integer("1");
int i=0;
integer div_temp=create_integer(div.num_components);
integer rem=create_integer(div.num_components+2);
while(compare_integers(div, zero) == 1){
set_zero_integer(rem);
mod_integer(div, two,rem);
copy_integer(div,div_temp);
divide_small_integer(div_temp,2,div);
if(compare_integers(rem, zero) == 1){
integer ptt=create_integer(power_of_two.num_components);
copy_integer(power_of_two,ptt);
factors.pushBack(ptt);
}
add_integer(power_of_two,one,power_of_two);
i++;
}
free_integer(rem);
free_integer(div_temp);
Array<integer> partial_results;
integer part_res=hex_to_integer(p,keyLengthBytes,2);
integer ri=hex_to_integer(r,keyLengthBytes,1);
integer idx = create_integer(part_res.num_components);
set_zero_integer(idx);
integer part_res_temp1=create_integer(part_res.num_components);
integer part_res_temp2=create_integer(part_res.num_components);
integer part_res_temp3=create_integer(part_res.num_components);
for(int i=0; i<factors.size(); i++){
while(compare_integers(factors[i],idx)==1){
copy_integer(part_res,part_res_temp1);
copy_integer(part_res,part_res_temp2);
multiply_integer(part_res_temp1,part_res_temp2,part_res);
copy_integer(part_res,part_res_temp3);
mod_integer(part_res_temp3,ri,part_res);
add_integer(idx,one,idx);
}
integer ptt=create_integer(part_res.num_components);
copy_integer(part_res,ptt);
partial_results.pushBack(ptt);
}
free_integer(part_res_temp1);
free_integer(part_res_temp2);
free_integer(part_res_temp3);
integer resulti=create_integer(ri.num_components+1);
set_zero_integer(resulti);
resulti.c[0]=1;
integer resulti_temp=create_integer(resulti.num_components);
integer resulti_temp2=create_integer(resulti.num_components);
for(int i=0; i<partial_results.size(); i++){
copy_integer(resulti,resulti_temp);
multiply_integer(resulti_temp,partial_results[i],resulti);
copy_integer(resulti,resulti_temp2);
mod_integer(resulti_temp2,ri,resulti);
}
free_integer(resulti_temp);
free_integer(resulti_temp2);
int lol=integer_to_binary(result,resulti,keyLengthBytes);
return lol;
}
