Trauma's questions

I am experimenting with asyncio(in python3.8). First of all, a small test of how to use asyncio.Queue; simply put a data in the queue and get it again.

import asyncio

class QServer:
    def _getQueue( self, queueName ):
        queue = self._queues.get( queueName )

        if queue is None:
            queue = asyncio.Queue( )
            self._queues[queueName] = asyncio.Queue( ) 

        return queue

    def __init__( self ):
        self._queues = { }

    async def put( self, queueName, data ):
        queue = self._getQueue( queueName )
        await queue.put( data )

    async def get( self, queueName ):
        queue = self._getQueue( queueName )
        return await queue.get( )

async def main( ):
    QueueName = 'TestQueue'
    TestData = 'TestData'

    queue = QServer( )

    print( 'put' )
    await queue.put( QueueName, TestData )
    internal = queue._getQueue( QueueName )
    print( internal.qsize( ) )
    print( 'type' )
    assert( type( queue._queues[ QueueName ] ) == type( asyncio.Queue( ) ) )
    print( 'get' )
    assert( await queue.get( QueueName ) == TestData )
    print( 'End' )

asyncio.run( main( ) )

The output I expected is:

put
1
type
get
End

However, I am getting this other one:

put
0
type
get

And there the program stays on hold indefinitely, until I press Ctrl+Cand finish it.

To my uninitiated eyes, it looks like it put( ) 's not putting anything in the queue. And I have a suspicion that I am not correctly understanding how coroutines work .

• What am I doing wrong ?
• How do I solve it ?

I'm doing a test with generators, to split a string into tokens . But the result obtained is not as expected:

function *stringIterator( str ) {
    for( const ch of str ) {
        yield ch
    }
}

function parseString( iterator ) {
    var value = '';

    for( const ch of iterator ) {
        if( ch == "'" ) { break; }

        value += ch;
    }

    return { value };
}

function *tokenGenerator( input ) {
    iterator = stringIterator( input );

    for( const ch of iterator ) {
        switch( ch ) {
        case "'":
            yield parseString( iterator );
            break;
        }
    }
}

for( const token of tokenGenerator( "'hola, mundo''hadios'" ) ) {
    console.log( token );
}

The value obtained by console is

{ value: 'hello, world' }

However, what I hope to get is

{ value: 'hello, world' }
{ value: 'goodbye' }

There are 3 functions involved, 2 of them being generators and the third being a normal function :

1. function *stringIterator( )

   Generator that loops through a string, returning one character at a time.

2. function parseString( )

   Normal function that, using the first, has to accumulate characters in a string, and return the accumulated string when the character found is a '(single quote).

3. function *tokenGenerator( )

   Generator function that creates a generator ( 1) from a string and should repeatedly call 2.

From the results obtained, it seems that as much 1as they 2work correctly, they fail 3(or my way of calling it).

• What am I doing wrong ?

• How do I solve it ?

I am making a kind of communications channel , which sends requests and receives responses.

The function that sends a request, I want it to return a Promise, which will be resolved by the receiving function (internal to the class).

And that's where I got stuck:

class IOChannel {
  constructor( channel ) {
    this.$channel = channel;
    this.$queue = { };

    channel.on( 'message', ( data ) => {
      if( 'error' in data ) {
        // Es una respuesta con un error. // <- ¿ ?
      } else if( 'result' in data ) {
        // Es una respuesta. // <- ¿ ?
    } );
  }

  $nextId( ) { ... }

  async sendRequest( params ) {
    this.$channel.send( {
      id: this.$nextId( ),
      params: params
    } );

    return new Promise( ); // <- ¿ ?
  }
}

Both outgoing requests and incoming responses are related by the idmessage attribute. The idea was to use the variable this.$queueas a join point between outgoing requests and incoming responses, based on that attribute id.

But I can't think of how to relate the response callbackmessage function to the one Promisegenerated in the function sendRequest( ).

How do I have to modify my code so that the function sendMessage( )returns a valid promise, which will be resolved or rejected by my callback function ?

edit

The intent is to call that function sendRequest( )from route handlers express:

const express = require( 'express' );

const app = express( );
const ioChannel = new IOChannel( process );

app.post( '/login', body-parser, function( req, res ) {
  const view = await ioChannel.send( {
    login: req.body.userId,
    pass: req.body.pass
  } );

  res.status( view ? 200 : 401 ).end( );
}

I am using the armadillo library to perform calculations with matrices, vectors, and other herbs .

To speed up build times, I'm trying to compile the instantiations into a single file, and declare all the templates as externthe files .cppthey're used in:

// Un archivo.cpp
#include <armadillo>

extern template class arma::SpMat< arma::uword >;
extern template class arma::SpMat< arma::sword >;
...

Centralizing all used instances in a new file:

// armadillo.cpp
#include <armadillo>

template class arma::SpMat< arma::uword >;
template class arma::SpMat< arma::sword >;
...

But, when trying to compile the file armadillo.cpp:

In instantiation of 'static void arma::arrayops::clean(eT*, arma::uword, eT, const typename arma::arma_not_cx::result*) [with eT = long long unsigned int; weapon::uword = long long unsigned int; typename weapon::arma_not_cx::result = long long unsigned int]':

required from 'const weapon::SpMat& weapon::SpMat::clean(typename weapon::get_pod_type::result) [with eT = long long unsigned int; typename weapon::get_pod_type::result = long long unsigned int]'

error: call of overloaded abs(long long unsigned int&)is ambiguous
val = (std::abs(val) <= abs_limit) ? eT(0) : val;

The protest refers to the first instance, arma::uword. The piece of code responsible is:

template<typename eT>
arma_hot
inline
void
arrayops::clean(eT* mem, const uword n_elem, const eT abs_limit, const typename arma_not_cx<eT>::result* junk)
  {
  arma_ignore(junk);
  
  for(uword i=0; i<n_elem; ++i)
    {
    eT& val = mem[i];
    
    val = (std::abs(val) <= abs_limit) ? eT(0) : val;
    }
  }

Of course, before trying this centralization , everything compiled and worked fine.

I understand that the complaint refers to the fact that several possible instantiations of std::abs( )are likely to compile properly for the type arma::uword. What creeps me out is that it only complains when doing explicit instantiation .

• Is there a difference between explicit instantiation and on-the-fly instantiation ?

• What am I doing wrong ?

• How do I solve it ?

I am configuring and testing source code coverage by the various tests . And sonarqubehe shows me totally incomprehensible results.

For example, this piece of code:

auto node_number = adjacencyMatrix.n_cols;
std::vector<bool> visited( node_number, false );
std::vector<std::vector<uword> > islands;
decltype( islands.size( ) ) island_idx = 0;
std::vector<uword> stack( node_number );

for ( uword node = 0; node < node_number; ++node ) {
    // Visited yet. Nothing.
    if ( !visited[ node ] ) {
        islands.emplace_back( );

It is placed right at the beginning of one of the functions to be tested , and that function has a single argument. The first 5 lines shown are simple statements with initial assignment.

However, sonarqubehe tells me that the coverage of the file is 38%, when I know that the test covers all the functions . In fact, he tells me that this line

std::vector<uword> stack( node_number );

is partially covered , when it is a simple declaration ! And even if we took into account all the possible calls to the constructor, it still wouldn't add up: the constructor ofstd::vector< > has 9 possible ways to be invoked.

I understand that sonarqubehe does nothing more than make beautiful the data he collects from the input file. I am generating the latter like this:

gcovr -r . -k --xml-pretty -o report.xml

And the compilations of the different translation units are done, ultimately, like this:

g++ -g -Wall -Wpedantic -Wextra -Og -g3 -ggdb -fprofile-arcs -ftest-coverage -std=c++17

What would be the correct interpretation of this coverage test ?

Am I using the correct arguments when compiling and calling gcovr?

I am doing an export of classes from c++ to python. Specifically, I have to export instances of the class Colfrom the libraryArmadillo (it's something like a std::vector< >).

This bookstore has a peculiarity. The access functions to the elements of an instance Col< >can be configured so that they perform the bounds check or not. But such configuration is done using a#define ARMA_NO_DEBUG . That is, it is done at the file level.cpp .

It turns out that in my C++ code I am not interested in such a check being performed. But in the code exported to python if . This implies that there will be files .cppin which said macro is defined, and others in which it is not.

Since I don't really trust what can happen in this situation, I have created 4 small test files. What I expected is that the linker would protest multiple definitions, or some similar error:

test.hpp

#ifndef TEST_HPP
#define TEST_HPP

#include <stdexcept>

template< typename T > T __attribute__ ((noinline)) dummy( const T &arg );

template< typename T > T __attribute__ ((noinline)) dummy( const T &arg ) {
#ifndef NDEBUG
  throw std::runtime_error( "" );
#endif

  return T( arg );
}

#endif

debug.cpp

#include "test.hpp"

int debug( int arg ) {
  return dummy( arg );
}

nodebug.cpp

#define NDEBUG

#include "test.hpp"

int nodebug( int arg ) {
  return dummy( arg );
}

main.cpp

#include <iostream>

extern int nodebug( int );
extern int debug( int );

int main( ) {
  int nd = nodebug( 10 );
  std::cout << "nodebug: " << nd << std::endl;
  int d = debug( 5 );
  std::cout << "debug: " << d << std::endl;

  return 0;
}

All this compiled with

g++ -std=c++11 -Wall -Wextra -pedantic -O3 nodebug.cpp debug.cpp main.cpp

With all of the above, the idea was to force the and functions to debug( )be nodebug( )external (and had to be bound), and to force the same for the template dummy< >( ). In fact, the order

nm -C main
0000000000001180 t int dummy<int>(int const&) [clone .isra.0]
0000000000001390 t int dummy<int>(int const&) [clone .isra.0]

shows 2 entries for dummy< >( ) with the same template parameters , which I didn't know was possible.

Well, after compiling and linking (which I was surprised it worked), I run el mainand get:

nodebug: 10
terminate called after throwing an instance of std::runtime_error
what():
Aborted

Which, things in life, is a result according to my code.

How is this possible ? Shouldn't a linking error have occurred because there are multiple different definitions of my template function dummy< >( )with different implementations? Have I made a mistake in my test code and am I actually doing something other than what I intended? And finally: Although I am forcing maximum compatibility when compiling ( -pedantic), is this standard behavior or am I (unknowingly and unintentionally) using some compiler extension?

As a result of this question

java.lang.NoClassDefFoundError with explicit CLASSPATH

It has emerged me a doubt. The Oracle documentation onCLASSPATH tells us:

The class path tells JDK tools and applications where to find third-party and user-defined classes -- that is, classes that are not Java extensions or part of the Java platform. The class path needs to find any classes you've compiled with the javac compiler -- its default is the current directory to conveniently enable those classes to be found ... Class paths to the .jar, .zip or .class files. Each classpath should end with a filename or directory depending on what you are setting the class path to:

• For a .jar or .zip file that contains .class files, the class path ends with the name of the .zip or .jar file.
• For .class files in an unnamed package, the class path ends with the directory that contains the .class files.
• For .class files in a named package, the class path ends with the directory that contains the "root" package (the first package in the full package name).
  
  Multiple path entries are separated by semi-colons.

However, from my experience, I have come to the conclusion that all the tutorials on the internet and the documentation itself are wrong .

The concrete case.

Let's put a minimal code file, which uses some external library:

import com.google.gson.Gson;

public class MCVE {
  public static void main( String [] args ) {
    System.out.println( " ***** Iniciando la prueba *****" );

    MCVE mcve = new MCVE( );
    String json = new Gson( ).toJson( mcve );
    System.out.println( json );

    System.out.println( " ***** Prueba terminada *****" );
  }
}

Likewise, a pom.xmlminimum, but that we copy the dependencies to a directory (in this case, target/libs):

<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>es.stackoverflow.com</groupId>
  <artifactId>MCVE</artifactId>
  <version>1.0</version>

  <properties>
    <maven.compiler.target>8</maven.compiler.target>
    <maven.compiler.source>8</maven.compiler.source>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <maven.test.skip>true</maven.test.skip>     
  </properties>
  <dependencies>
    <dependency>
          <!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
          <groupId>com.google.code.gson</groupId>
          <artifactId>gson</artifactId>
          <version>2.8.5</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-jar-plugin</artifactId>
        <configuration>
          <archive>
            <manifest>
                <mainClass>MCVE</mainClass>
            </manifest>
          </archive>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-dependency-plugin</artifactId>
        <executions>
          <execution>
            <id>copy-dependencies</id>
            <phase>prepare-package</phase>
            <goals>
              <goal>copy-dependencies</goal>
            </goals>
            <configuration>
              <outputDirectory>${project.build.directory}/libs</outputDirectory>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>

All this placed in a more or less standard directory hierarchy:

/mcve
+-pom.xml
+-src
   +-main
      +-java
         +-MCVE.java

We compile it:

>mvn package

After which, our directory hierarchy contains:

/mcve
+-pom.xml
+-src/
| +-main/
| +-java/
| +-MCVE.java
+-target/
   +-MCVE-1.0.jar
      +-libs/
         +-gson-2.8.5.jar

Also, we look inside the .jar, the file MANIFEST.MF:

Manifest-Version: 1.0
Archiver-Version: Plexus Archiver
Built-By: root
Created-By: Apache Maven 3.6.3
Build-Jdk: 1.8.0_252-ea
Main-Class: MCVE

Now, we run it:

>cd target
>CLASSPATH='libs/' java -jar MCVE-1.0.jar

But it seems that he doesn't like it :

>java -jar MCVE-1.0.jar
***** Starting test *****
Exception in thread "main" java.lang.NoClassDefFoundError: com/google/gson/Gson
 at MCVE.main(MCVE.java: 9)
Caused by: java.lang.ClassNotFoundException: com.google.gson.Gson
 at java.net.URLClassLoader.findClass(URLClassLoader.java:382)
 at java.lang.ClassLoader.loadClass(ClassLoader.java:418)
 at sun .misc.Launcher$AppClassLoader.loadClass(Launcher.java:352)
 at java.lang.ClassLoader.loadClass(ClassLoader.java:351)
 ... 1 more

We continue testing all possible ways to indicate the CLASSPATH:

>CLASSPATH='libs' java -jar MCVE-1.0.jar
>CLASSPATH='/root/mcve/target/libs/' java -jar MCVE-1.0.jar
>CLASSPATH='/root/mcve/target/libs' java -jar MCVE-1.0.jar
>export CLASSPATH='/root/mcve/target/libs/'; java -jar MCVE-1.0.jar
>CLASSPATH='libs/gson-2.8.5.jar' java -jar MCVE-1.0.jar
>CLASSPATH='/root/mcve/target/libs/gson-2.8.5.jar' java -jar MCVE-1.0.jar
...
>java -cp 'libs/' -jar MCVE-1.0.jar
>java -cp 'libs/' -jar MCVE-1.0.jar
>java -cp '/root/mcve/target/libs/gson-2.8.5.jar' -jar MCVE-1.0.jar
...

In all cases I get the same exception.

In which authorized source is the behavior of java and CLASSPATH explained and detailed according to the results observed?

Doing a recursion experiment with templates, I've come up with this:

#include <iostream>
#include <utility>

template< int INDEX = 0 >
void constexpr callInTuple( int index ) {
  if( INDEX == index ) {
    std::cout << INDEX << '\n';
  } else {
    std::cout << "Intentando con " << INDEX << ", fallido\n";
    callInTuple< INDEX + 1 >( index );
  }
}

int main( ) {
  callInTuple( 1 );

  return 0;
}

What I expect, when calling the function with the literal argument 1, is that something like this will be displayed on the screen:

Trying 0, failed
1

But it doesn't even compile, showing the error in the title:

template instantiation depth exceeds maximum ...

If I try it by calling the function like

callInTuple( 0 );

I would expect an even shorter output, like so:

0

However, I get the exact same error .

• What am I doing wrong ?

• How do I solve it ?

I'm making a C++ code tokenizer , using C++ :-)

At the moment, I only support encoded source filesUTF8 , so to process the input file, I'm reading line by line and using a simple const char *to access each individual character.

To localize the literal strings with prefix , I use the following:

static size_t parseIdentifier( CppToken &tk, const char *beg, const char *end ) {
  while( ( ( beg != end ) && *beg <= ' ' ) ) ++beg;

  if( beg == end ) return 0;

  if( strncmp( beg, "L\"", 2 ) { return parseStringLiteralL( tk, beg, end ); }
  if( strncmp( beg, "u\"", 2 ) { return parseStringLiteralu( tk, beg, end ); }
  if( strncmp( beg, "U\"", 2 ) { return parseStringLiteralU( tk, beg, end ); }

  ...
}

And here is my question: within those functions parseStringLiteralX( ), should I interpret the strings in the source file with size prefix that they are still encoded in UTF8, or on the contrary, must they be previously encoded according to the prefix used?

The documentation that I have found does not clarify what to do:

Phase 5

1) All characters in character literals and string literals are converted from the source character set to the execution character set (which may be a multibyte character set such as UTF-8, as long as the 96 characters of the basic source character set listed in phase 1 have single-byte representations).

And I don't know how to apply this to my functions parseStringLiteralX( ). That is, the different functions should start like this, with a type conversion:

static size_t parseStringLiteralL( CppToken &tk, const char *beg, const char *end ) {
  const wchar_t *wbeg = reinterpret_cast< const wchar_t * >( beg );
  const wchar_t *wend = reinterpret_cast< const wchar_t * >( end );
  ...
}

or, conversely , I am to assume that the literal strings are still inUTF8 , and I am the one who has to transform them to the type indicated by the prefix ?

static size_t parseStringLiteralL( CppToken &tk, const char *beg, const char *end ) {
  std::wstring value;

  while( *beg != '"' ) value.append( 1, utf8_to_wchart( *beg ) );

  ...
}

_{Note : the actual source code is not like this , it is just illustrative.}

EDIT

I've tried this little test to try to clear it up:

#include <string>
#include <iostream>

int main( ) {
  const wchar_t *test = L"el niño y la niña\n";

  std::cout << reinterpret_cast< const char * >( test ) << '\n';
  std::wcout << test << std::endl;

  return 0;
}

I expected the text to display correctly at least 1 time. However, I get the following:

and
the boy and the girl

Well, I just realized that it will depend on the coding that WandBox supports... but I'll leave it there, in case it's useful to someone.

For certain reasons, I need to call placement new on an already correctly created instance , but with its VPTRincorrect . I have obtained it from a file, from a socket , ... the method does not matter.

It's a class with member-functions virtual, so I need to call the constructor to properly initialize the VPTR.

However, the constructor initializes all member-variables. If it was primitive data , I wouldn't have a problem. But they are not . Some of the member-variables have their own constructor.

Thinking about it, I found a solution... Call the copy constructor on the instance itself!

#include <iostream>

struct Dato {
  int x = 0,
      y = 0;
};

struct Padre {
  Dato datos;

  virtual ~Padre( ) {
  }
};

struct Hija : public Padre {
};

int main( ) {
  Hija h;

  h.datos.x = 10;
  h.datos.y = 20;

  Hija *ptr = new ( &h ) Hija( h );

  std::cout << "x: " << ptr->datos.x << ", y: " << ptr->datos.y << '\n';

  return 0;
}

_{The example is available at Wandbox.}

The result obtained is the one sought:

x: 10, y: 20

The questions:

1. How portable is this?

2. I understand that a recursive call is made to the various constructors involved. Is there another method that gives the same result (initialize the VPTR without overwriting the rest of the memory), bypassing those calls?

I'm trying to understand how await/ works async. I have read several opinions that come to say

async/ awaitis nothing more than a sugar-syntax on Promises .

However, the output I'm getting collides head -on with this: I'm not able to explain the outputs of the following code (originally taken from here ).

function sleep( ms ) {
  return new Promise( resolve => setTimeout( resolve, ms ) );
}

async function demo( ) {
  console.log( 'Taking a break...' );
  await sleep( 2000 );
  console.log( 'Two seconds later' );
}

async function demo2( ) {
  console.log( 'demo2 -> before' );
  await demo( );
  console.log( 'demo2 -> after' );
}

function demo3( ) {
  console.log( 'demo3 -> before' );
  demo2( );
  console.log( 'demo3 -> after' );
}

demo3( );

The result obtained is:

demo3 -> before
demo2 -> before
Taking a break...
demo3 -> after
... 2 seconds pause ...
Two seconds later
demo2 -> after

However , the expected result is this one:

demo3 -> before
demo2 -> before
Taking a break...
Two seconds later
demo2 -> after
demo3 -> after

In some way that I don't understand, the use of async/ changes the order of the returns await! I can't think of any way, using only callbacks and closures , that would cause that behavior.

From the outputs, it seems that the function demo3( )returns before the function demo2( ), which is simply impossible according to the classic execution mode that I know.

How does it really async work / await? Is it really just a facility to use Promises ? Am I messing myself up looking los 3 pies del gato?

I compile a program with gcc. From VSCodeI open a font file, and I set a breakpoint.

Next, on the target machine, I launch the gdbserverwith the appropriate arguments. The debugger runs and waits for connections.

From VSCodethe debug view, I launch remote debugging. All correct, it connects to the gdbserver.

As soon as the breakpoint is hit, the source file is closed , and the VSCodedisplays the window with the warning:

Cannot open nombre-del-archivo: File not found (file:///full/path/to/the/file)

I'm building from a VM, where the project directory is correctly shared between Windows (host) and Linux (guest). From Linux, the shared folder (as shown in the image) is /media/sf_D_Drive.

Of course, the file that supposedly doesn't exist is present:

How VSCodedo I get the source file to not close, or show the error window, when I reach the breakpoint?

EDIT

I just realized the problem: I compile from the VM, but VSCodeI'm running it from the host machine; the executable has the paths relative to the VM, while the paths on Windows (host) are different.

Path on Linux:/media/sf_D_DRIVE/CMS/Subversion/CORE_5G/src/com

Path on Windows:D:\CMS\Subversion\CORE_5G\src\com

File .vscode\launch.json:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "(gdbserver) Launch",
      "type": "cppdbg",
      "request": "launch",
      "program": "${workspaceFolder}/bin/CFGP_bin_ConfigParam_cos",
      "args": [],
      "stopAtEntry": false,
      "cwd": "${workspaceFolder}",
      "environment": [],
      "externalConsole": true,
      "MIMode": "gdb",
      "miDebuggerPath": "c:/cygwin64/bin/gdb.exe",
      "miDebuggerServerAddress": "214.25.250.7:10000",
      "targetArchitecture": "x86",
      "linux": {
        "MIMode": "gdb"
      },
      "windows": {
        "MIMode": "gdb"
      },
      "setupCommands": [
        {
          "description": "Enable pretty-printing for gdb",
          "text": "-enable-pretty-printing",
          "ignoreFailures": true
        }
      ]
    }
  ]
}

I have the following class:

class Utf8Writer {
  struct ZoneData {
    uint32_t begin; // codepoint inicial.
    uint32_t end; // codepoint final.
  };

  const ZoneData *findCodepoint( uint32_t cp, FontId fid );
};

const ZoneData *Utf8Writer::findCodepoint( uint32_t cp, FontId fid ) {
  auto iter = std::find_if( fid->cbegin( ), fid->cend( ), [cp] ( ZoneData i ) { return ( cp >= i.begin ) && ( cp <= i.end ); } );

  return ( iter == fid->cend( ) ) ? nullptr : &( *iter );
}

It works perfectly, except that it is a bug . What I really wanted to do is:

const ZoneData *Utf8Writer::findCodepoint( uint32_t cp, FontId fid ) {
  auto iter = std::find_if( fid->cbegin( ), fid->cend( ), [cp] ( const ZoneData &i ) { return ( cp >= i.begin ) && ( cp <= i.end ); } );

  return ( iter == fid->cend( ) ) ? nullptr : &( *iter );
}

In fact, if we look at the doc of std::find_if( ):

template< class InputIt, class UnaryPredicate > InputIt find_if( InputIt first, InputIt last, UnaryPredicate p );

being UnaryPredicate->bool pred( const Type &a );

I understand that, in the first version, the compiler creates a temporary, calling the default-copy constructor . It turns out that the class ZoneDatais more complex than shown: it includes std::vectorand other things , and its copy is not trivial (neither in time nor in memory usage).

• Is it possible to avoid creating temporary lambda calls , for future occasions, without touching the class ZoneData?

I am using uGui to display fonts on screen. But the final result is not as satisfactory as it should be. The hardware is quite limited: 8 bpp color (256 colors total), with 3 bits for red, 3 bits for green, and 2 bits for blue ( 3:3:2 ).

The original code to get the color of a point is:

color = (((fc & 0xFF) * b + (bc & 0xFF) * (256 - b)) >> 8) & 0xFF |//Blue component
        (((fc & 0xFF00) * b + (bc & 0xFF00) * (256 - b)) >> 8)  & 0xFF00|//Green component
        (((fc & 0xFF0000) * b + (bc & 0xFF0000) * (256 - b)) >> 8) & 0xFF0000; //Red component

Being:

• fc: uint32_t, the ink color for that character.
• bc: uint32_t, the background color for that character.
• b: uint8_t, ink/background mixture percentage for a specific point of the character.

This last data is taken from the font file, previously rendered (using an external utility) and converted to array[]de unsigned char, in which each element represents the ink/background ratio of the dot.

The results of the original code are quite satisfactory:

But there are several color artifacts (especially in the A). If we zoom ...

In an attempt on my part to limit or eliminate this, and taking into account that only certain colors are used for the text/background, it occurred to me to artificially limit the number of possible colors to be applied for smoothing : for example, if the ink is black, use only the gray color for the points that are not ink or background.

The code was like this:

// Calculamos el color para el antialiasing.
UG_COLOR acolor; // unsigned char
switch( fc ) {
case 0x92: // GRAY
  acolor = 0xDB;
  break;
case 0x1C: // GREEN
  acolor = 0x5E;
  break;
case 0xF0: // ORANGE
  acolor = 0x90;
  break;
case 0xDB: // SEMI_WHITE
  acolor = 0xFF;
  break;
default: // BLACK
  acolor = 0xB6; // GRAY;
  break;
}

color = (((fc & 0xFF) * b + (bc & 0xFF) * (256 - b)) >> 8) & 0xFF |//Blue component
        (((fc & 0xFF00) * b + (bc & 0xFF00) * (256 - b)) >> 8)  & 0xFF00|//Green component
        (((fc & 0xFF0000) * b + (bc & 0xFF0000) * (256 - b)) >> 8) & 0xFF0000; //Red component

// Si no vamos a pintar ni con la tinta ni con el fondo, lo hacemos
// con el color para el antialiasing.
if( ( color != fc ) && ( color != bc ) ) color = acolor;

The result was... different :

It can be seen that the inappropriate colored dots have almost disappeared, but the overall quality ... leaves a lot to be desired.

What is the correct way to perform this type of smoothing? What bit combination/operation should I perform?

_{Note: C or C++, bitwise operations are the same in both.}

EDIT

In reply to @abufalia.

To paint a pixel on the screen, use a unsigned char:

*((unsigned char *)(posicion-en-memoria)) = color;

Being colora UG_COLOR, which in turn is a uint32_t.

In all paint text operations, the value of fcy bcis limited to 8 bits:

const UG_COLOR BLACK      = 0X00;
const UG_COLOR GRAY       = 0x92;
const UG_COLOR SEMI_WHITE = 0xDB;
const UG_COLOR WHITE      = 0XFF;
const UG_COLOR GREEN      = 0X1C;
const UG_COLOR ORANGE     = 0XF0;

To obtain the percentage of mixture, use:

b = font->p[index++];

being:

typedef struct {
   unsigned char* p;
   FONT_TYPE font_type;
   UG_S16 char_width;
   UG_S16 char_height;
   UG_U16 start_char;
   UG_U16 end_char;
   UG_U8  *widths;
} UG_FONT;

RAII ( resource acquisition is initialization ) is a common language in C++; I recently had a small problem using it, which I summarize in this code (the code is not valid, it is for illustrative purposes only ):

template< typename T > class Algo {
  bool enqueue( T arg ) {
    struct raii {
      T val;
      ~raii( ) {
        // Hacemos algo con las variables ...
      }
    } RAII = { arg };

    // Cuerpo real de la función ...
  }

  // Resto de la plantilla ...
};

Inside the function enqueue( )we create a control structure; its only mission is to guarantee that a part of our code will be executed, even in the presence of exceptions . The C++ language guarantees that the destructor will be called . It is the equivalent in C++ to the blocks finally { ... }present in other languages.

The problem I've run into is that the compiler, in an effort to keep us out of trouble, gives us an unused variable warning :

warning: unused RAII variable

In modern compilers , we can use the new features of C++11; specifically, the attributes ; more exactly, in C++17 we can use

} RAII [[maybe_unused]] = { arg };

In g++, we can use __attribute((unused))__or [[gnu::unused]](depending on the version). And it even sounds like something to me pragma _Unusedin other compilers.

Other, more manual methods consist of declaring and using a constructor; this way, the compiler sees that we 're using the instance, and doesn't give us its well-intentioned warning either.

The question:

Doesn't C++ provide a standard, agreed mechanism for using RAII? That is, to inform the compiler that the only use of an instance is to call its destructor.

It's something I do regularly; For example, in this hypothetical function

function fetchData( url, args, callback, opts ) {
  var ajax = webix.ajax( );

  ...

  function success( text, data, xhr ) {
    var response;

    ...

    setTimeout( function( ) { callback( response ); }, 0 );
  }

  function failure( ) {
    var response;

    ...

    setTimeout( function( ) { callback( response ); }, 0 }
  }
}

It would be a function to make AJAX calls , check for possible errors, and return output in a common format, whether there were errors or not.

Since it is a function that makes an AJAX call , it is asynchronous. Therefore, I can't directly return the value, so I use the callback. When I have something to return, I call that function.

The logic I've always used is:

Since JavaScript is event based, and events are not processed while we are executing code, it is best to finish the code as soon as possible .

So instead of doing:

callback( response );

That would increase the continuous execution time of my code, I do this other:

setTimeout( function( ) { callback( response ); }, 0 );

This would create an event in the queue to make the call to callback( ). My Javascript code terminates, and the browser can continue processing its tidbits .

Am I correct in doing so? Is there some possible side effect hidden and waiting to attack me at any moment?

I am trying to compile a package; specifically, the plugin gkrellm-leds for gkrellm. I downloaded the sources from packages.ubuntu.com/source/zesty/gkrellm-leds .

After compiling and installing it, it doesn't work. The program that should use it, gkrellm, doesn't even show it as an available plugin .

Since this is not the first time these things have happened to me, the first thing I did was

> ldd gkleds.so

linux-vdso.so.1 => (0x00007ffe15def000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f2fc6f37000)
/lib64/ld-linux-x86-64.so.2 (0x0000557eb4014000)

I know that this package uses the GTK-2.0 libraries, as well as others. In fact, the source code is full of calls to functions of these libraries.

The Makefileone in the package is:

SHELL = /bin/sh
VPATH = src:src/pixmaps

GTK_INCLUDE = `pkg-config gtk+-2.0 --cflags`
GTK_LIB = `pkg-config gtk+-2.0 --libs`

X11_LIB = -L/usr/X11R6/lib -lX11 -lXtst

LIBS = $(GTK_LIB) $(X11_LIB)
DEFINES =
LFLAGS = -shared
INCLUDES = $(GTK_INCLUDE)
CFLAGS = -ansi -pedantic -Wall -O2 -fPIC 
CC = gcc

SRCS = gkleds.c
HDRS = gkleds.h
OBJS = gkleds.o
IMAGES = leds.xpm

DESTDIR = 

INSTALL_PROG = install

.PHONY : clean
.PHONY : install
.PHONY : uninstall
.PHONY : test

#=======================================================================
#=======================================================================

gkleds.so : $(OBJS)
    $(CC) $(LFLAGS) $(LIBS) -o $@ $< 

gkleds.o : $(SRCS) $(HDRS) $(IMAGES)
    $(CC) $(CFLAGS) $(INCLUDES) $(DEFINES) -c -o $@ $< 

test :
    $(MAKE) clean
    $(MAKE) DEFINES="-DGKLEDS_DEBUG"
    gkrellm --sync --demo -p gkleds.so
    $(MAKE) clean

clean:
    rm -rf *.o *.so* *~ \#*
    rm -rf src/*~ src/\#*

install : gkleds.so
    @ if [ "$$UID" -ne 0 ]; \
        then PLUGIN_DIR=$$HOME/.gkrellm2/plugins; \
    elif [ -e /usr/bin/gkrellm ]; \
        then PLUGIN_DIR=/usr/lib/gkrellm2/plugins; \
    else \
        PLUGIN_DIR=/usr/local/lib/gkrellm2/plugins; \
    fi; \
    $(INSTALL_PROG) -d $(DESTDIR)/$$PLUGIN_DIR; \
    $(INSTALL_PROG) -s gkleds.so $(DESTDIR)/$$PLUGIN_DIR; \
    printf "\ngkleds installed in $$PLUGIN_DIR\n"

All build dependencies are correctly installed, as well as the pkg-configcorresponding ones:

> pkg-config gtk+-2.0 --cflags

-pthread -I/usr/include/gtk-2.0 -I/usr/lib/x86_64-linux-gnu/gtk-2.0/include -I/usr/include/gio-unix-2.0/ -I/usr/include/ cairo -I/usr/include/pango-1.0 -I/usr/include/atk-1.0 -I/usr/include/cairo -I/usr/include/pixman-1 -I/usr/include/libpng16 -I/ usr/include/gdk-pixbuf-2.0 -I/usr/include/libpng16 -I/usr/include/pango-1.0 -I/usr/include/harfbuzz -I/usr/include/pango-1.0 -I/usr/ include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -I/usr/include/freetype2

> pkg-config gtk+-2.0 --libs

-lgtk-x11-2.0 -lgdk-x11-2.0 -lpangocairo-1.0 -latk-1.0 -lcairo -lgdk_pixbuf-2.0 -lgio-2.0 -lpangoft2-1.0 -lpango-1.0 -lgobject-2.0 -lglib-2.0 -lfontconfig -lfreetype

Anyway, to be safe, I dumped the results of pkg-configinto a separate file, extra.mk, and modified the Makefileoriginal to include my own, adding include extra.mkand removing the definitions of GTK_INCLUDEand GTK_LIB.

After that small modification, doing make, apart from several irrelevant warnings , shows the following:

gcc -DGKLEDS_DEBUG -ansi -pedantic -Wall -O2 -fPIC -pthread -I/usr/include/gtk-2.0 -I/usr/lib/x86_64-linux-gnu/gtk-2.0/include -I/usr/include/ gio-unix-2.0/ -I/usr/include/cairo -I/usr/include/pango-1.0 -I/usr/include/atk-1.0 -I/usr/include/cairo -I/usr/include/pixman -1 -I/usr/include/libpng16 -I/usr/include/gdk-pixbuf-2.0 -I/usr/include/libpng16 -I/usr/include/pango-1.0 -I/usr/include/harfbuzz -I /usr/include/pango-1.0 -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -I/usr/include/freetype2 -c -o gkleds. o src/gkleds.c ...
... VARIOUS WARNINGS ...
...
gcc -shared -lgtk-x11-2.0 -lgdk-x11-2.0 -lpangocairo-1.0 -latk-1.0 -lcairo -lgdk_pixbuf-2.0 - lgio-2.0 -lpangoft2-1.0 -lpango-1.0 -lgobject-2.0 -lglib-2.0 -lfontconfig -lfreetype -lX11 -lXtst -o gkleds.so gkleds.o

It can be seen how, in the last part, it calls gccwith the correct options and libraries.

However, if I redo

> ldd gkleds.so

linux-vdso.so.1 => (0x00007ffe15def000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f2fc6f37000)
/lib64/ld-linux-x86-64.so.2 (0x0000557eb4014000)

It still doesn't show GTK or any other dependencies , apart from those added by default by the gcc.

1. Why aren't references to the external libraries used by the package included?
2. How do I solve it ?

This is a snippet from a file I currently use:

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8"/>
<link id="SKIN.CSS" rel="stylesheet" charset="UTF-8"/>
<script id="APP.JS" type="text/javascript" charset="UTF-8"></script>
<script id="GUI.JS" type="text/javascript" charset="UTF-8"></script>
<title></title>
</head>
<body>
<script>

window.Gui = { };

window.App = { }

( function( ) {
  var ajax = new XMLHttpRequest( ),
      remains = 3, // Archivos que faltan por cargar.
      response,
      tmp;

  // Solicitamos los archivos a cargar.
  ajax.onreadystatechange = onResponse;
  ajax.open( 'POST', 'config.php' );
  ajax.send( );

  function onResponse( ) {
    if( ( ajax.readyState == 4 ) && ( ajax.status == 200 ) ) {
      response = JSON.parse( ajax.responseText );

      // Cargamos el resto de archivos.
      tmp = document.getElementById( 'SKIN.CSS' );
      tmp.onload = onLoaded;
      tmp.href = response.skin;

      tmp = document.getElementById( 'APP.JS' );
      tmp.onload = onLoaded;
      tmp.src = response.app;

      tmp = document.getElementById( 'GUI.JS' );
      tmp.onload = onLoaded;
      tmp.src = response.gui;
    }
  }

  function onLoaded( ) {
    -- remains;
console.log( 'remains:', remains );

    if( !remains )
      setTimeout( Run, 0 );
  }

  function Run( ) {
  console.log( 'Se llamó a RUN( ).' );

    Gui.Init( );
    setTimeout( App.Run, 0 );
  }
} )( );
</script>
</body>
</html>

I make an AJAX call to get the names of 3 files to upload, and set the attributes by handsrc= and href=as appropriate, to load them dynamically.

The matter is in

function onLoaded( ) {
  -- remains;
  console.log( 'remains:', remains );

  if( !remains )
    setTimeout( Run, 0 );
}

This code, in other languages, would be more than enough reason for direct expulsion from the guild .

Suppose the following sequence of events occurs:

1. The SKIN.CSS.
2. The function is called loaded( ), which is executed completely. `remains === 2'.
3. The APP.JS.
4. The function is called loaded( ).
5. Inside loaded( ), decrement remains , which passes to === 1.
6. Before entering the if, theGUI.JS .
7. It runs loaded( ). remains === 0.
8. I enter the if( ). The condition is met. It runs App.Run( ).
9. The browser continues at point 6, but now I can enter the if( ), becauseremains === 0 ( it was not when it was interrupted).
10. is called a second timeApp.Run( ) .

Is this sequence of events possible in Javascript, or does the language guarantee that no function will be interrupted by any event?

NOTE

Although it doesn't affect the template code ( utf8iterator.hpp), main.cpp it depends on the encoding used when saving it to work correctly. On my system, I work with UTF-8, and said main.cppis saved in the same encoding.

Thanks to user @asdasdasd for letting me know with his comments.

END OF NOTE

After reading this question: Why doesn't cout show vowels with tilde or “ñ” with gcc 4.9.4? , I felt the uncontrollable urge to iterate over individual characters within a ::std::string, or within a const char[].

After doing some research on the UTF-8 Wikipedia page , I coded this simple template

// utf8iterator.hpp

#ifndef UTF8ITERATOR_HPP
#define UTF8ITERATOR_HPP

#include <cstddef>

template< typename T > struct utf8iterator {
  //static constexpr char ReplacementCharacter[4] { '\xEF', '\xBF', '\xBD', '\x00' };

  T ptr;
  ::size_t size; // Tamaño del caracter, en bytes. == 0 -> ptr ha cambiado.
                 // Su única misión es evitar escrituras no necesarias.
  char bytes[5]; // Máximo tamaño de un UTF-8 es 4. Dejamos sitio para el 0 al final.

  utf8iterator( const T &p ) :
    ptr( p ),
    size( 0 )
  {
    bytes[4] = 0; // Solo lo hacemos 1 vez. Nunca se sobreescribe.
  }
  utf8iterator &operator=( const T &iter ) {
    ptr = iter;
    size = 0;
    return *this;
    // Ya hicimos 'bytes[4] = 0' en el constructor.
  }

  bool operator==( const utf8iterator< T > &other ) const noexcept { return ptr == other.ptr; }
  bool operator!=( const utf8iterator< T > &other ) const noexcept { return ptr != other.ptr; }

  ::size_t calculateSize( ) const {
    if( ( *ptr & 248 ) == 240 ) { // 11110
      return 4;
    } else if( ( *ptr & 240 ) == 224 ) { // 1110
      return 3;
    } else if( ( *ptr & 224 ) == 192 ) // 110
      return 2;

    return 1;
  }
  utf8iterator &operator++( ) {
    if( size ) {
      ptr += size;
      size = 0; // Al cambiar 'ptr', se invalida 'size'.
    } else
      ptr += calculateSize( ); // 'size' ya es inválido.

    return *this;
  }
  utf8iterator operator++( int ) {
    utf8iterator tmp( *this );

    if( size ) {
      ptr += size;
      size = 0; // Al cambiar 'ptr', se invalida 'size'.
    } else
      ptr += calculateSize( ); // 'size' ya es inválido.

    return tmp;
  }

  operator const char *( ) {
    // Si 'size' es inválido, tenemos que calcular el tamaño del caracter, en bytes.
    if( !size ) {
      ::size_t c;
      T iter( ptr );

      size = calculateSize( );

      // Subsceptible de optimizar, especializando para < const char * >, y usando ::std::memcpy( ).
      // Copiamos los bytes indicados en 'size' al buffer 'bytes'.
      for( c = 0; c != size; ++c ) {
        bytes[c] = *iter;
        ++iter;
      }

      // En el constructor, hicimos 'bytes[4] = 0'. Las escrituras son costosas.
      // Solo ponemos el 0 si 'bytes != 4'.
      if( size != 4 )
        bytes[size] = 0;
    }

    return bytes;
  }
};

#endif

Accompanied by a small test code

// main.cpp

#include <iostream>

#include "utf8iterator.hpp"

int main( void ) {
  const char *test = "abcdeññ";

  utf8iterator< const char * > charIter( test );

  while( *charIter ) {
    std::cout << charIter.size( ) << ": ";
    std::cout << *charIter << "\n";
    ++charIter;
  }

  std::cout << std::endl;

  return 0;
}

All this compiles correctly with

g++ -I . -std=c++11 -Wall -pedantic -o test test.cpp

The expected result would be

1: a
1: b
1: c
1: d
1: e
2: ñ
2: ñ

However, the result obtained is this other:

1: a
1: b
1: c
1: d
1: e
2:
2:

I'm pretty sure the bug is in const char *utf8iterator::operator*( ), but I can't hit the key .

Any suggestion ?

EDIT

Heh, in the end the shots don't go that way, but how I print it in the test ; I have the C++ somewhat rusty . I leave her unanswered for a while.

I currently use the following code to detect the screen size:

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title></title>
  </head>
  <body>
    <div id="FSAUX" style="height:1em;width:1em;left:100%;position:fixed;top:100%;"></div>
    <div id="CMAUX" style="height:1cm;width:1cm;left:100%;position:fixed;top:100%;"></div>

    <script type="text/javascript">
SCREEN = {
  FBS: document.getElementById( 'FSAUX' ).offsetWidth,
  CENTS: screen.width / document.getElementById( 'CMAUX' ).offsetWidth,
  CHARS: screen.width / document.getElementById( 'FSAUX' ).offsetWidth,
  WIDTH: screen.width
};

if( ( SCREEN.WIDTH < 800 ) ||
    ( SCREEN.CENTS < 10 ) ||
    ( SCREEN.CHARS < 80 ) ) {
  document.title = 'Pantalla pequeña';
} else {
  document.title = 'Pantalla grande';
}
    </script>
  </body>
</html>

I set minimum sizes for various factors: points, centimeters, and base font size. Depending on the above, I load one or another version of my application. Once one version is uploaded , I can't upload another one. They have very different interfaces and do not implement the same features.

The problem arises on steerable or rotatable devices . Depending on the orientation (horizontal/vertical) I get some or other screen values.

This means that it loads the version for small screens, when in reality the user would just have to rotate the device, placing it horizontally to be able to use the version for large screens .

I don't want to detect the browser. I am only interested in knowing if the device is orientable or not .

Is there a way to check it in Javascript? Preferably pure ; If a library is needed, I'll search its code to see how it implements it.