Merge branch 'master' of ssh://git.dcc.fc.up.pt/yap-6.3

This commit is contained in:
Vitor Santos Costa 2016-08-26 06:09:38 +01:00
commit a5c09f9187
32 changed files with 907 additions and 3465 deletions

View File

@ -661,26 +661,31 @@ static Int atom_concat3(USES_REGS1) {
Term t1; Term t1;
Term t2, t3, ot; Term t2, t3, ot;
Atom at; Atom at;
bool g1, g2, g3;
restart_aux: restart_aux:
t1 = Deref(ARG1); t1 = Deref(ARG1);
t2 = Deref(ARG2); t2 = Deref(ARG2);
t3 = Deref(ARG3); t3 = Deref(ARG3);
if (Yap_IsGroundTerm(t1) && Yap_IsGroundTerm(t2)) { g1 = Yap_IsGroundTerm(t1);
g2 = Yap_IsGroundTerm(t2);
g3 = Yap_IsGroundTerm(t3);
if (g1 && g2) {
at = Yap_ConcatAtoms(t1, t2 PASS_REGS); at = Yap_ConcatAtoms(t1, t2 PASS_REGS);
ot = ARG3; ot = ARG3;
} else if (Yap_IsGroundTerm(t1) && Yap_IsGroundTerm(t3)) { } else if (g1 && g3) {
at = Yap_SubtractHeadAtom(Deref(ARG3), t1 PASS_REGS); at = Yap_SubtractHeadAtom(t3, t1 PASS_REGS);
ot = ARG2; ot = ARG2;
} else if (Yap_IsGroundTerm(t2) && Yap_IsGroundTerm(t3)) { } else if (g2 && g3) {
at = Yap_SubtractTailAtom(Deref(ARG3), t2 PASS_REGS); at = Yap_SubtractTailAtom(t3, t2 PASS_REGS);
ot = ARG1; ot = ARG1;
} else if (Yap_IsGroundTerm(t3)) { } else if (g3) {
EXTRA_CBACK_ARG(3, 1) = MkIntTerm(0); EXTRA_CBACK_ARG(3, 1) = MkIntTerm(0);
EXTRA_CBACK_ARG(3, 2) = MkIntTerm(Yap_AtomToLength(t3 PASS_REGS)); EXTRA_CBACK_ARG(3, 2) = MkIntTerm(Yap_AtomToLength(t3 PASS_REGS));
return cont_atom_concat3(PASS_REGS1); return cont_atom_concat3(PASS_REGS1);
} else { } else {
LOCAL_Error_TYPE = INSTANTIATION_ERROR; LOCAL_Error_TYPE = INSTANTIATION_ERROR;
LOCAL_Error_Term = t1; LOCAL_Error_Term = t1;
at = NULL;
} }
if (at) { if (at) {
if (Yap_unify(ot, MkAtomTerm(at))) if (Yap_unify(ot, MkAtomTerm(at)))
@ -693,7 +698,7 @@ restart_aux:
if (Yap_HandleError("atom_concat/3")) { if (Yap_HandleError("atom_concat/3")) {
goto restart_aux; goto restart_aux;
} else { } else {
return FALSE; return false;
} }
} }
cut_fail(); cut_fail();
@ -751,29 +756,34 @@ static Int atomic_concat3(USES_REGS1) {
Term t1; Term t1;
Term t2, t3, ot; Term t2, t3, ot;
Atom at = NULL; Atom at = NULL;
bool g1, g2, g3;
restart_aux: restart_aux:
t1 = Deref(ARG1); t1 = Deref(ARG1);
t2 = Deref(ARG2); t2 = Deref(ARG2);
t3 = Deref(ARG3); t3 = Deref(ARG3);
if (Yap_IsGroundTerm(t1) && Yap_IsGroundTerm(t2)) { g1 = Yap_IsGroundTerm(t1);
at = Yap_ConcatAtoms(CastToAtom(t1), CastToAtom(t2) PASS_REGS); g2 = Yap_IsGroundTerm(t2);
g3 = Yap_IsGroundTerm(t3);
if (g1 && g2) {
at = Yap_ConcatAtomics(t1, t2 PASS_REGS);
ot = ARG3; ot = ARG3;
} else if (Yap_IsGroundTerm(t1) && Yap_IsGroundTerm(t3)) { } else if (g1 && g3) {
at = Yap_SubtractHeadAtom(t3, CastToAtom(t1) PASS_REGS); at = Yap_SubtractHeadAtom(t3, t1 PASS_REGS);
ot = ARG2; ot = ARG2;
} else if (Yap_IsGroundTerm(t2) && Yap_IsGroundTerm(t3)) { } else if (g2 && g3) {
at = Yap_SubtractTailAtom(t3, CastToAtom(t2) PASS_REGS); at = Yap_SubtractTailAtom(t3, t2 PASS_REGS);
ot = ARG1; ot = ARG1;
} else if (Yap_IsGroundTerm(t3)) { } else if (g3) {
EXTRA_CBACK_ARG(3, 1) = MkIntTerm(0); EXTRA_CBACK_ARG(3, 1) = MkIntTerm(0);
EXTRA_CBACK_ARG(3, 2) = MkIntTerm(Yap_AtomicToLength(t3 PASS_REGS)); EXTRA_CBACK_ARG(3, 2) = MkIntTerm(Yap_AtomicToLength(t3 PASS_REGS));
return cont_atomic_concat3(PASS_REGS1); return cont_atomic_concat3(PASS_REGS1);
} else { } else {
LOCAL_Error_TYPE = INSTANTIATION_ERROR; LOCAL_Error_TYPE = INSTANTIATION_ERROR;
LOCAL_Error_Term = t1; LOCAL_Error_Term = t1;
at = NULL;
} }
if (at) { if (at) {
if (Yap_unify(ot, CastToNumeric(at))) if (Yap_unify(ot, MkAtomTerm(at)))
cut_succeed(); cut_succeed();
else else
cut_fail(); cut_fail();
@ -783,7 +793,7 @@ restart_aux:
if (Yap_HandleError("atomic_concat/3")) { if (Yap_HandleError("atomic_concat/3")) {
goto restart_aux; goto restart_aux;
} else { } else {
return FALSE; return false;
} }
} }
cut_fail(); cut_fail();
@ -822,40 +832,45 @@ static Int string_concat3(USES_REGS1) {
Term t1; Term t1;
Term t2, t3, ot; Term t2, t3, ot;
Term tf = 0; Term tf = 0;
bool g1, g2, g3;
Atom at;
restart_aux: restart_aux:
t1 = Deref(ARG1); t1 = Deref(ARG1);
t2 = Deref(ARG2); t2 = Deref(ARG2);
t3 = Deref(ARG3); t3 = Deref(ARG3);
if (Yap_IsGroundTerm(t1) && Yap_IsGroundTerm(t2)) { g1 = Yap_IsGroundTerm(t1);
g2 = Yap_IsGroundTerm(t2);
g3 = Yap_IsGroundTerm(t3);
if (g1 && g2) {
tf = Yap_ConcatStrings(t1, t2 PASS_REGS); tf = Yap_ConcatStrings(t1, t2 PASS_REGS);
ot = ARG3; ot = ARG3;
} else if (Yap_IsGroundTerm(t1) && Yap_IsGroundTerm(t3)) { } else if (g1 && g3) {
tf = Yap_SubtractHeadString(t3, t1 PASS_REGS); tf = Yap_SubtractHeadString(t3, t1 PASS_REGS);
ot = ARG2; ot = ARG2;
} else if (Yap_IsGroundTerm(t2) && Yap_IsGroundTerm(t3)) { } else if (g2 && g3) {
tf = Yap_SubtractTailString(t3, t2 PASS_REGS); tf = Yap_SubtractTailString(t3, t2 PASS_REGS);
ot = ARG1; ot = ARG1;
} else if (Yap_IsGroundTerm(t3)) { } else if (g3) {
EXTRA_CBACK_ARG(3, 1) = MkIntTerm(0); EXTRA_CBACK_ARG(3, 1) = MkIntTerm(0);
EXTRA_CBACK_ARG(3, 2) = MkIntTerm(Yap_StringToLength(t3 PASS_REGS)); EXTRA_CBACK_ARG(3, 2) = MkIntTerm(Yap_StringToLength(t3 PASS_REGS));
return cont_string_concat3(PASS_REGS1); return cont_string_concat3(PASS_REGS1);
} else { } else {
LOCAL_Error_TYPE = INSTANTIATION_ERROR; LOCAL_Error_TYPE = INSTANTIATION_ERROR;
LOCAL_Error_Term = t1; LOCAL_Error_Term = t1;
at = NULL;
} }
if (tf) { if (tf) {
if (Yap_unify(ot, tf)) { if (Yap_unify(ot, tf))
cut_succeed(); cut_succeed();
} else { else
cut_fail(); cut_fail();
}
} }
/* Error handling */ /* Error handling */
if (LOCAL_Error_TYPE) { if (LOCAL_Error_TYPE) {
if (Yap_HandleError("string_concat/3")) { if (Yap_HandleError("atom_concat/3")) {
goto restart_aux; goto restart_aux;
} else { } else {
return FALSE; return false;
} }
} }
cut_fail(); cut_fail();

View File

@ -104,6 +104,7 @@ static Int SkipListCodes(unsigned char **bufp, Term *l, Term **tailp,
*bufp = st = st0; *bufp = st = st0;
if (*l == TermNil) { if (*l == TermNil) {
st[0] = '\0';
return 0; return 0;
} }
if (IsPairTerm(*l)) { if (IsPairTerm(*l)) {
@ -311,7 +312,7 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
} else if (!IsStringTerm(inp->val.t) && } else if (!IsStringTerm(inp->val.t) &&
inp->type == YAP_STRING_STRING) { inp->type == YAP_STRING_STRING) {
LOCAL_Error_TYPE = TYPE_ERROR_STRING; LOCAL_Error_TYPE = TYPE_ERROR_STRING;
} else if (!IsPairTerm(inp->val.t) && !IsStringTerm(inp->val.t) && } else if (!IsPairOrNilTerm(inp->val.t) && !IsStringTerm(inp->val.t) &&
inp->type == inp->type ==
(YAP_STRING_ATOMS_CODES | YAP_STRING_STRING)) { (YAP_STRING_ATOMS_CODES | YAP_STRING_STRING)) {
LOCAL_Error_TYPE = TYPE_ERROR_LIST; LOCAL_Error_TYPE = TYPE_ERROR_LIST;
@ -344,20 +345,20 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
return UStringOfTerm(inp->val.t); return UStringOfTerm(inp->val.t);
} }
if (((inp->type & (YAP_STRING_CODES | YAP_STRING_ATOMS)) == if (((inp->type & (YAP_STRING_CODES | YAP_STRING_ATOMS)) ==
(YAP_STRING_CODES | YAP_STRING_ATOMS)) && IsPairTerm(inp->val.t)) { (YAP_STRING_CODES | YAP_STRING_ATOMS)) && IsPairOrNilTerm(inp->val.t)) {
//Yap_DebugPlWriteln(inp->val.t); //Yap_DebugPlWriteln(inp->val.t);
return inp->val.uc = return inp->val.uc =
Yap_ListToBuffer(s0, inp->val.t, inp, &wide, lengp Yap_ListToBuffer(s0, inp->val.t, inp, &wide, lengp
PASS_REGS); PASS_REGS);
// this is a term, extract to a sfer, and representation is wide // this is a term, extract to a sfer, and representation is wide
} }
if (inp->type & YAP_STRING_CODES && IsPairTerm(inp->val.t)) { if (inp->type & YAP_STRING_CODES && IsPairOrNilTerm(inp->val.t)) {
//Yap_DebugPlWriteln(inp->val.t); //Yap_DebugPlWriteln(inp->val.t);
return inp->val.uc = Yap_ListOfCodesToBuffer(s0, inp->val.t, inp, &wide, return inp->val.uc = Yap_ListOfCodesToBuffer(s0, inp->val.t, inp, &wide,
lengp PASS_REGS); lengp PASS_REGS);
// this is a term, extract to a sfer, and representation is wide // this is a term, extract to a sfer, and representation is wide
} }
if (inp->type & YAP_STRING_ATOMS && IsPairTerm(inp->val.t)) { if (inp->type & YAP_STRING_ATOMS && IsPairOrNilTerm(inp->val.t)) {
//Yap_DebugPlWriteln(inp->val.t); //Yap_DebugPlWriteln(inp->val.t);
return inp->val.uc = Yap_ListOfAtomsToBuffer(s0, inp->val.t, inp, &wide, return inp->val.uc = Yap_ListOfAtomsToBuffer(s0, inp->val.t, inp, &wide,
lengp PASS_REGS); lengp PASS_REGS);
@ -1031,7 +1032,7 @@ const char *Yap_TextTermToText(Term t, char *buf, size_t len, encoding_t enc) {
CACHE_REGS CACHE_REGS
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t; inp.val.t = t;
if (IsAtomTerm(t)) { if (IsAtomTerm(t) && t != TermNil) {
inp.type = YAP_STRING_ATOM; inp.type = YAP_STRING_ATOM;
if (IsWideAtom(AtomOfTerm(t))) if (IsWideAtom(AtomOfTerm(t)))
inp.enc = ENC_WCHAR; inp.enc = ENC_WCHAR;
@ -1040,7 +1041,7 @@ const char *Yap_TextTermToText(Term t, char *buf, size_t len, encoding_t enc) {
} else if (IsStringTerm(t)) { } else if (IsStringTerm(t)) {
inp.type = YAP_STRING_STRING; inp.type = YAP_STRING_STRING;
inp.enc = ENC_ISO_UTF8; inp.enc = ENC_ISO_UTF8;
} else if (IsPairTerm(t)) { } else if (IsPairOrNilTerm(t)) {
inp.type = (YAP_STRING_CODES | YAP_STRING_ATOMS); inp.type = (YAP_STRING_CODES | YAP_STRING_ATOMS);
} else { } else {
Yap_Error(TYPE_ERROR_TEXT, t, NULL); Yap_Error(TYPE_ERROR_TEXT, t, NULL);

View File

@ -1,2 +0,0 @@
* Threads Support <http://www.gnu.org/software/threads>
GNU Threads Library (or similar)

View File

@ -1,2 +0,0 @@
* GNU libgmp (in some cases MPIR - GNU big integers and rationals
* libreadline - Readline line editing library

View File

@ -350,4 +350,14 @@ INLINE_ONLY inline EXTERN void *AddressOfTerm(Term t) {
return (void *)(IsIntTerm(t) ? IntOfTerm(t) : LongIntOfTerm(t)); return (void *)(IsIntTerm(t) ? IntOfTerm(t) : LongIntOfTerm(t));
} }
INLINE_ONLY inline EXTERN Int IsPairTermOrNil (Term);
INLINE_ONLY inline EXTERN Int
IsPairOrNilTerm (Term t)
{
return IsPairTerm(t) || t == TermNil;
}
#endif #endif

View File

@ -1,72 +0,0 @@
## YAPDroid
This file documents the YAPDroid application. This app was developed in order to
test the YAP-Android interface. It provides a simple REPL with a query window and a text
viewer.
### Design
The YAP interface to Android is based on the SWIG interface generator. SWIG exports the YAP
C++ classes as Java classes. In practice there exist two worlds, the native application
and the Java application:
- YAP runs in Android as a native application in a Linux
environment. Android does not support glibc. Instead, Android libraries are provided by the Android NDK, and
are somewhat limited, i.e., the NDK misses in-memory streams and a `glob`
predicate. Moreover, read-only data is kept in a zipped archive that is made to appear as
a directory, `~/assets`
- SWIG generates the glue code: JNI classes that act as Java classes. Callbacks are possible.
- Java code operates as usual.
### Compiling YAPDroid
The current version was compiled using the recent Android Studio `cmake` support. Android Studio uses
`gradle` as the build system. `gradle` orchestrates compilation of all Java code. External code is delegated
to `cmake` or the Android NDK own builder. The idea fits nicely with YAP; unfortunately, the process currently
crashes in middle.
To install, navigate through these steps:
1. Obtain `gmp` for Android. YAP has used the [Rupan repo](https://github.com/Rupan/gmp); place the repo next to
the yap-6.3 top directory.
2. Install [swig](www/swig.org)
2. Obtain Android Studio. This work used Android Studio 2.2 Beta 3. The IDE includes most everything else you need: the ADK, the NDK, `cmake`, the `ninja` build system, and the debugger.
3. Set YAPDroid as your directory.
4. Adapt the `build.gradle` files to your configuration.
+ It may be a good idea to first generate an empty configuration and compare.
+ In the `lib` directory, please verify wich targets you are generating for.
4. Build the system, either from the GUI or from a terminal, say as:
~~~~~
./gradlew assembleDebug
~~~~~
or
~~~~~
./gradlew :lib:assembleDebug
~~~~~
You should see `cmake` being executed, and after some time `gradle` crash.
5. To actually install the binaries, use:
~~~~~
cd lib/build/intermediates/cmake/debug/json/armeabi-v7a
ninja install
~~~~~
6. Comment the four lines in `lib/build.gradle` to avoid crashing in the `cmake` task.
7. use the GUI commands to compile the app or set your directory bak to
the YAPDroid top-directory and call `gradle`.
Enjoy!
### Limitations and TODO
- improve error handling.
- support `/assets`: the code is written but not tested yet.
- network access
- sqlite testing and support

View File

@ -1,37 +0,0 @@
apply plugin: 'com.android.application'
android {
compileSdkVersion 23
buildToolsVersion "23.0.3"
defaultConfig {
applicationId "pt.up.yap.app"
minSdkVersion 19
targetSdkVersion 23
versionCode 1
versionName "1.0"
testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
}
project.gradle.taskGraph.whenReady {
connectedDebugAndroidTest {
ignoreFailures = true
}
}
dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
compile 'com.android.support:appcompat-v7:23.4.0'
testCompile 'junit:junit:4.12'
androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2.2'
androidTestCompile 'com.android.support.test:runner:0.5'
androidTestCompile 'com.android.support:support-annotations:23.4.0'
compile 'com.google.android.gms:play-services-appindexing:8.4.0'
}

View File

@ -1,21 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="pt.up.yap.app"
android:versionCode="1"
android:versionName="1.0">
<application android:label="@string/app_name" android:icon="@drawable/ic_launcher"
android:theme="@style/AppTheme"
>
<activity android:name=".YAPDroid"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity><!-- ATTENTION: This was auto-generated to add Google Play services to your project for
App Indexing. See https://g.co/AppIndexing/AndroidStudio for more information. -->
<meta-data
android:name="com.google.android.gms.version"
android:value="@integer/google_play_services_version" />
</application>
</manifest>

View File

@ -1,86 +0,0 @@
package pt.up.yap.app;
import android.content.Context;
import android.content.res.AssetManager;
import android.support.v4.content.res.ResourcesCompat;
import android.util.Log;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* Created by vsc on 30/05/16.
*/
public class CreateFiles {
public static void setupfiles(Context context, AssetManager assets){
try {
context.getExternalFilesDir("Yap").mkdirs();
context.getExternalFilesDir("Yap/pl").mkdirs();
context.getExternalFilesDir("Yap/os").mkdirs();
String list[] = {};
list= assets.list("Yap");
for (int i = 0; i < list.length; i++) {
copy(context, "Yap/"+ list[i]);
}
list = null;
list= assets.list("Yap/pl");
for (int i = 0; i < list.length; i++) {
copy(context, "Yap/pl/"+ list[i]);
}
list =null;
list= assets.list("Yap/os");
for (int i = 0; i < list.length; i++) {
copy(context, "Yap/os/"+ list[i]);
}
Log.d("CreateFiles", context.getFilesDir().getAbsolutePath());
} catch (IOException e) {
e.printStackTrace();
}
}
private static void copy(Context context, String originalName) {
try {
if (originalName.contains(".")) {
File outFile;
outFile = new File(context.getExternalFilesDir(null), originalName );
InputStream in = context.getAssets().open(originalName);
BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(outFile));
byte data[] = new byte[1024];
int count;
while ((count = in.read(data)) != -1) {
out.write(data, 0, count);
}
out.flush();
out.close();
in.close();
in = null;
out = null;
//Log.d("Copied: ", originalName + " to " + destinationName);
//System.out.println("Copied: "+ originalName + " to " + destinationName);
//System.out.println();
}
}catch(IOException e){
e.printStackTrace();
}
}
}

View File

@ -1,330 +0,0 @@
package pt.up.yap.app;
/****
* using sqlite
* For example,the following:
* <p/>
* import android.database.sqlite.SQLiteDatabase;
* <p/>
* should be replaced with:
* <p/>
* import org.sqlite.database.sqlite.SQLiteDatabase;
* <p/>
* As well as replacing all uses of the classes in the android.database.sqlite.* namespace, the application must also be sure to use the following two:
* <p/>
* org.sqlite.database.SQLException
* org.sqlite.database.DatabaseErrorHandler
* <p/>
* instead of:
* <p/>
* android.database.SQLException
* android.database.DatabaseErrorHandler
* <p/>
* Aside from namespace changes, there are other differences from the stock Android interface that applications need to be aware of:
* <p/>
* The SQLiteStatement.simpleQueryForBlobFileDescriptor() API is not available. The collation sequence "UNICODE" is not available. The collation sequence "LOCALIZED", which normally changes with the system's current locale, is always equivalent to SQLite's built in collation BINARY.
****/
import android.content.Context;
import android.app.Activity;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.content.res.AssetManager;
import android.net.Uri;
import android.os.Bundle;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import android.text.method.ScrollingMovementMethod;
import android.util.Log;
import android.view.View;
import android.widget.EditText;
import android.widget.ScrollView;
import android.widget.TextView;
import com.google.android.gms.appindexing.Action;
import com.google.android.gms.appindexing.AppIndex;
import com.google.android.gms.appindexing.Thing;
import com.google.android.gms.common.api.GoogleApiClient;
import org.sqlite.database.DatabaseErrorHandler;
import org.sqlite.database.sqlite.SQLiteDatabase;
import pt.up.yap.lib.*;
class DoNotDeleteErrorHandler implements DatabaseErrorHandler {
private static final String TAG = "DoNotDeleteErrorHandler";
public void onCorruption(SQLiteDatabase dbObj) {
Log.e(TAG, "Corruption reported by sqlite on database: " + dbObj.getPath());
}
}
public class YAPDroid extends Activity {
private static final String TAG = "YAPDroid";
TextView outputText = null;
ScrollView scroller = null;
YAPEngine eng = null;
EditText text;
String str;
String buf;
YAPQuery q;
Boolean running = false, compute = true;
int i = 1;
YAPListTerm vs0;
private AssetManager mgr;
/**
* ATTENTION: This was auto-generated to implement the App Indexing API.
* See https://g.co/AppIndexing/AndroidStudio for more information.
*/
private GoogleApiClient client;
// private static native void load(AssetManager mgr);
void runQuery(String str, Boolean more) {
try {
// check if at initial query
if (running) {
if (q != null) q.close();
}
if (BuildConfig.DEBUG) {
Log.i(TAG, "query " + str);
}
q = eng.query(str);
// get the uninstantiated query variables.
vs0 = q.namedVars();
running = true;
// start computing
compute = true;
if (BuildConfig.DEBUG) {
Log.i(TAG, "onQueryButtonClick called");
}
Boolean rc = true;
text.setText("?- ");
if (vs0.nil()) {
if (BuildConfig.DEBUG) {
Log.i(TAG, "q0=\n");
}
if (compute && (rc = q.next())) {
outputText.append("yes\n");
running = compute = more;
} else {
outputText.append("no\n");
running = false;
compute = false;
}
} else {
// if (BuildConfig.DEBUG) {
// Log.i(TAG, "q1= " + vs0.text() + "\n");
// }
while (compute && (rc = q.next())) {
YAPListTerm vs = q.namedVars();
while (!vs.nil()) {
if (BuildConfig.DEBUG) {
Log.i(TAG, "q= " + vs.text() + "\n");
}
YAPTerm eq = vs.car();
//outputText.append(Integr.toString(i) + ": " + eq.text() );
outputText.append(Integer.toString(i));
outputText.append(":\t" + eq.getArg(1).text() + " = " + eq.getArg(2).text() + "\n");
vs = vs.cdr();
}
compute = more;
}
}
if (!rc) {
outputText.append("no\n");
if (q != null)
q.close();
q = null;
compute = false;
running = false;
}
} catch (Exception e) {
outputText.append("Exception thrown :" + e);
if (q != null)
q.close();
compute = true;
running = false;
}
}
/**
* Called when the activity is first created.
*/
@Override
public void onCreate(Bundle savedInstanceState) {
String s = null;
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
try {
PackageManager
m = getPackageManager();
s = getPackageName();
PackageInfo p = m.getPackageInfo(s, 0);
//s = p.applicationInfo.dataDir;
mgr = this.getAssets();
/** static constructor */
// follow this order carefully.
System.loadLibrary("gmp");
System.loadLibrary("Yap");
System.loadLibrary("Yapsqlite3");
System.loadLibrary("Yap++");
System.loadLibrary("YAPDroid");
CreateFiles.setupfiles(this, mgr);
} catch (NameNotFoundException e) {
Log.e(TAG, "Couldn't find package information in PackageManager", e);
}
Log.i(TAG, "mgr=" + mgr);
text = (EditText) findViewById(R.id.EditText01);
outputText = (TextView) findViewById(R.id.OutputText);
outputText.setText("Application " + s + "\nPress 'First' or 'All' to query...\n");
outputText.setMovementMethod(new ScrollingMovementMethod());
scroller = (ScrollView) findViewById(R.id.Scroller);
if (BuildConfig.DEBUG) {
Log.i(TAG, "window making done");
}
eng = new YAPEngine(null, this.getExternalFilesDir("/Yap/pl/boot.yap").getAbsolutePath());
if (BuildConfig.DEBUG) {
Log.i(TAG, "engine done");
}
if (BuildConfig.DEBUG) {
Log.i(TAG, "onClearButtonClick called");
}
JavaCallback callback = new JavaCallback(outputText);
// set the Java Callback
if (BuildConfig.DEBUG) {
Log.i(TAG, "before setting callback");
}
eng.setYAPCallback(callback);
if (BuildConfig.DEBUG) {
Log.i(TAG, "callback done");
}
// ATTENTION: This was auto-generated to implement the App Indexing API.
// See https://g.co/AppIndexing/AndroidStudio for more information.
client = new GoogleApiClient.Builder(this).addApi(AppIndex.API).build();
}
public void onClearButtonClick(View view) {
if (BuildConfig.DEBUG) {
Log.i(TAG, "onClearButtonClick called");
}
// Ensure scroll to end of text
scroller.post(new Runnable() {
public void run() {
scroller.fullScroll(ScrollView.FOCUS_DOWN);
if (running) {
if (q != null)
q.close();
q = null;
}
running = false;
text.setText("");
}
});
}
public void onFirstButtonClick(View view) {
if (BuildConfig.DEBUG) {
Log.i(TAG, "onQueryButtonClick called");
}
// Ensure scroll to end of text
scroller.post(new Runnable() {
public void run() {
scroller.fullScroll(ScrollView.FOCUS_DOWN);
str = text.getText().toString();
//outputText.append("?- " + str+"\n\n");
Log.i(TAG, "onQueryAnyButtonClick " + str + "\n");
runQuery(str, false);
scroller.fullScroll(ScrollView.FOCUS_DOWN);
}
});
}
public void onAllButtonClick(View view) {
if (BuildConfig.DEBUG) {
Log.i(TAG, "onQueryButtonClick called");
}
// Ensure scroll to end of text
scroller.post(new Runnable() {
public void run() {
str = text.getText().toString();
scroller.fullScroll(ScrollView.FOCUS_DOWN);
outputText.append("?- " + str + "\n\n");
Log.i(TAG, "onAllButtonClick " + str + "\n");
runQuery(str, true);
scroller.fullScroll(ScrollView.FOCUS_DOWN);
}
});
}
/**
* ATTENTION: This was auto-generated to implement the App Indexing API.
* See https://g.co/AppIndexing/AndroidStudio for more information.
*/
public Action getIndexApiAction() {
Thing object = new Thing.Builder()
.setName("YAPDroid Page") // TODO: Define a title for the content shown.
// TODO: Make sure this auto-generated URL is correct.
.setUrl(Uri.parse("http://[ENTER-YOUR-URL-HERE]"))
.build();
return new Action.Builder(Action.TYPE_VIEW)
.setObject(object)
.setActionStatus(Action.STATUS_TYPE_COMPLETED)
.build();
}
@Override
public void onStart() {
super.onStart();
// ATTENTION: This was auto-generated to implement the App Indexing API.
// See https://g.co/AppIndexing/AndroidStudio for more information.
client.connect();
AppIndex.AppIndexApi.start(client, getIndexApiAction());
}
@Override
public void onStop() {
super.onStop();
// ATTENTION: This was auto-generated to implement the App Indexing API.
// See https://g.co/AppIndexing/AndroidStudio for more information.
AppIndex.AppIndexApi.end(client, getIndexApiAction());
client.disconnect();
}
}
class JavaCallback extends YAPCallback {
private static final String TAG = "JavaCallback";
TextView output;
public JavaCallback(TextView outputText) {
super();
output = outputText;
Log.i(TAG, "java callback init");
}
public void run(String s) {
Log.i(TAG, "java callback ");
output.append(s);
}
}

View File

@ -1,62 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical"
tools:context=".YAPDroid">
<LinearLayout
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:orientation="horizontal">
<EditText
android:id="@+id/EditText01"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_weight="1.0"
android:lines="6" />
<LinearLayout
android:layout_width="wrap_content"
android:layout_height="fill_parent"
android:orientation="vertical">
<Button
android:id="@+id/FirstButton"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:onClick="onFirstButtonClick"
android:text="First..." />
<Button
android:id="@+id/AllButton"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:onClick="onAllButtonClick"
android:text="All..." />
<Button
android:id="@+id/ClearButton"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:onClick="onClearButtonClick"
android:text="Reset" />
</LinearLayout>
</LinearLayout>
<ScrollView
android:id="@+id/Scroller"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
<TextView
android:id="@+id/OutputText"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:singleLine="false" />
<!-- Set MaxLegth EditText -->
</ScrollView>
</LinearLayout>

View File

@ -1,23 +0,0 @@
// Top-level build file where you can add configuration options common to all sub-projects/modules.
buildscript {
repositories {
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:2.2.0-alpha7'
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files
}
}
allprojects {
repositories {
jcenter()
}
}
task clean(type: Delete) {
delete rootProject.buildDir
}

View File

@ -1,42 +0,0 @@
apply plugin: 'com.android.application'
android {
compileSdkVersion 23
buildToolsVersion "23.0.3"
defaultConfig {
applicationId "pt.up.yap.app"
minSdkVersion 19
targetSdkVersion 23
versionCode 1
versionName "1.0"
testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
cmake {
// cFlags "-DTEST_C_FLAG1" "-DTEST_C_FLAG2"
// cppFlags "-DTEST_CPP_FLAG2" "-DTEST_CPP_FLAG2"
abiFilters "armeabi-v7a", "x86"
}
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
// externalNativeBuild {
// cmake {
// path '../../CMakeLists.txt'
// }
// }
}
dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
compile 'com.android.support:appcompat-v7:23.4.0'
testCompile 'junit:junit:4.12'
androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2.2'
androidTestCompile 'com.android.support.test:runner:0.5'
androidTestCompile 'com.android.support:support-annotations:23.4.0'
}

View File

@ -1 +0,0 @@
include ':app', ':lib'

View File

@ -316,9 +316,9 @@ static YAP_Bool rename_file(void) {
static YAP_Bool read_link(void) { static YAP_Bool read_link(void) {
char *s1 = (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG1)); char *s1 = (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG1));
#if HAVE_READLINK #if HAVE_READLINK
char buf[PATH_MAX + 1]; char buf[MAXPATHLEN + 1];
if (readlink(s1, buf, PATH_MAX) < 0) if (readlink(s1, buf, MAXPATHLEN) < 0)
return false; return false;

View File

@ -5,7 +5,35 @@ main :-
Plt = matplotlib.pyplot, Plt = matplotlib.pyplot,
:= import( Plt ), := import( Plt ),
:= ( := (
Plt.figure(figsize=(10,2.5)),
Plt.plot([1,2,3,4]), Plt.plot([1,2,3,4]),
Plt.ylabel(`some numbers`), Plt.ylabel(`some numbers`),
Plt.show() Plt.show()
). ).
main2 :-
:= ( import( numpy),
import( matplotlib.mlab),
import( matplotlib.pyplot) ),
NP = numpy,
Mlab = matplotlib.mlab,
Plt = matplotlib.pyplot,
% example data
mu := 100, % mean of distribution,
sigma := 15, % standard deviation of distribution,
x := mu + sigma * NP.random.randn(10000),
num_bins := 50,
% the histogram of the data
(n, bins, patches) := Plt.hist(x, num_bins, normed=1, facecolor= `green`, alpha=0.5),
% add a `best fit` line
y := Mlab.normpdf(bins, mu, sigma),
:= (Plt.plot(bins, y, `r--`),
Plt.xlabel(`Smarts`),
Plt.ylabel(`Probability`),
Plt.title(`Histogram of IQ: $\\mu=100$, $\\sigma=15$`),
% Tweak spacing to prevent clipping of ylabel,
Plt.subplots_adjust(left=0.15),
Plt.show()).

View File

@ -0,0 +1,7 @@
:- use_module( library(python) ).
:- := import(pandas)).
pred2panda(Pred, Obj) :-

View File

@ -1,26 +0,0 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "MetaKernel YAP 3",
"language": "prolog",
"name": "yap_kernel"
},
"widgets": {
"state": {},
"version": "1.1.2"
}
},
"nbformat": 4,
"nbformat_minor": 0
}

File diff suppressed because it is too large Load Diff

View File

@ -1,86 +0,0 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"code_folding": [],
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<ipywidgets.widgets.widget_selection.ToggleButtons object at 0x105e24da0>\n",
"No (more) answers\n"
]
}
],
"source": [
":= import(mathplot).\n",
"X := plot([1,2,3])"
]
}
],
"metadata": {
"kernelspec": {
"display_name": " YAP-6.3",
"language": "prolog",
"name": "yap_kernel"
},
"language_info": {
"codemirror_mode": {
"name": "prolog",
"version": 2
},
"file_extension": ".yap",
"help_links": [
{
"text": "MetaKernel Magics",
"url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md"
}
],
"mimetype": "text/prolog",
"name": "text",
"pygments_lexer": "prolog",
"version": "0.0.1"
},
"latex_envs": {
"bibliofile": "biblio.bib",
"cite_by": "apalike",
"current_citInitial": 1,
"eqLabelWithNumbers": true,
"eqNumInitial": 0
},
"nav_menu": {},
"toc": {
"navigate_menu": true,
"number_sections": true,
"sideBar": true,
"threshold": 6,
"toc_cell": false,
"toc_section_display": "block",
"toc_window_display": false
},
"widgets": {
"state": {
"09b21d398da9424d94cf3c8e51054154": {
"views": []
},
"369de2fecba34468a7c9cf64076bac60": {
"views": []
},
"7f758a42f83c469882761606f7f8133e": {
"views": []
},
"c028bb350ed6424eb48a02762907868d": {
"views": []
}
},
"version": "1.1.2"
}
},
"nbformat": 4,
"nbformat_minor": 0
}

View File

@ -1,3 +1,2 @@
"""A Prolog kernel for Jupyter""" from ._version import version_info, __version__, kernel_protocol_version_info, kernel_protocol_version
from ipykernel.connect import *
__version__ = '0.0.1'

View File

@ -1,6 +1,3 @@
try: if __name__ == '__main__':
from ipykernel.kernelapp import IPKernelApp from yap_kernel import kernelapp as app
except ImportError: app.launch_new_instance()
from IPython.kernel.zmq.kernelapp import IPKernelApp
from .kernel import YAPKernel
IPKernelApp.launch_instance(kernel_class=YAPKernel)

View File

@ -0,0 +1,5 @@
version_info = (4, 4, 1)
__version__ = '.'.join(map(str, version_info))
kernel_protocol_version_info = (5, 0)
kernel_protocol_version = '%s.%s' % kernel_protocol_version_info

View File

@ -1,48 +0,0 @@
import base64
import imghdr
import os
#from IPython.
_TEXT_SAVED_IMAGE = "yap_kernel: saved image data to:"
image_setup_cmd = """
display () {
TMPFILE=$(mktemp ${TMPDIR-/tmp}/yap_kernel.XXXXXXXXXX)
cat > $TMPFILE
echo "%s $TMPFILE" >&2
}
""" % _TEXT_SAVED_IMAGE
def display_data_for_image(filename):
with open(filename, 'rb') as f:
image = f.read()
os.unlink(filename)
image_type = imghdr.what(None, image)
if image_type is None:
raise ValueError("Not a valid image: %s" % image)
image_data = base64.b64encode(image).decode('ascii')
content = {
'data': {
'image/' + image_type: image_data
},
'metadata': {}
}
return content
def extract_image_filenames(output):
output_lines = []
image_filenames = []
for line in output.split("\n"):
if line.startswith(_TEXT_SAVED_IMAGE):
filename = line.rstrip().split(": ")[-1]
image_filenames.append(filename)
else:
output_lines.append(line)
output = "\n".join(output_lines)
return image_filenames, output

View File

@ -1,44 +0,0 @@
import json
import os
import sys
try:
from jupyter_client.kernelspec import install_kernel_spec
except ImportError:
from IPython.kernel.kernelspec import install_kernel_spec
from IPython.utils.tempdir import TemporaryDirectory
kernel_json = {
"argv": [sys.executable,
"-m", "yap_kernel",
"-f", "{connection_file}"],
"display_name": "yap",
"mimetype": "text/x-prolog",
"language": "prolog",
"name": "yap",
}
def install_my_kernel_spec(user=False):
with TemporaryDirectory() as td:
os.chmod(td, 0o755) # Starts off as 700, not user readable
with open(os.path.join(td, 'kernel.json'), 'w') as f:
json.dump(kernel_json, f, sort_keys=True)
# TODO: Copy resources once they're specified
print('Installing IPython kernel spec')
install_kernel_spec(td, 'yap', user=False, replace=True)
def _is_root():
return True
try:
return os.geteuid() == 0
except AttributeError:
return False # assume not an admin on non-Unix platforms
def main(argv=[]):
user = '--user' in argv or not _is_root()
install_my_kernel_spec(user=user)
if __name__ == '__main__':
main(argv=sys.argv)

View File

@ -1,5 +1,15 @@
:- if( current_prolog_flag(apple, true) ). :- if( current_prolog_flag(apple, true) ).
:- putenv( 'LC_CTYPE', 'en_us:UTF-8'), :- putenv( 'LC_CTYPE', 'en_us:UTF-8').
plot_inline :-
X := self.inline_plotting,
nb_setval(inline, X ),
X = true,
!,
:= (
import( matplotlib ),
matplotlib.use( `nbagg` )
).
:- endif. :- endif.

View File

@ -0,0 +1,488 @@
"""An Application for launching a kernel"""
# Copyright (c) IPython Development Team.
# Distributed under the terms of the Modified BSD License.
from __future__ import print_function
import atexit
import os
import sys
import signal
import traceback
import logging
from tornado import ioloop
import zmq
from zmq.eventloop import ioloop as zmq_ioloop
from zmq.eventloop.zmqstream import ZMQStream
from IPython.core.application import (
BaseIPythonApplication, base_flags, base_aliases, catch_config_error
)
from IPython.core.profiledir import ProfileDir
from IPython.core.shellapp import (
InteractiveShellApp, shell_flags, shell_aliases
)
from IPython.utils import io
from ipython_genutils.path import filefind, ensure_dir_exists
from traitlets import (
Any, Instance, Dict, Unicode, Integer, Bool, DottedObjectName, Type, default
)
from ipython_genutils.importstring import import_item
from jupyter_core.paths import jupyter_runtime_dir
from jupyter_client import write_connection_file
from jupyter_client.connect import ConnectionFileMixin
# local imports
from ipykernel.iostream import IOPubThread
from ipykernel.heartbeat import Heartbeat
from .yap_kernel import YAPKernel
from ipykernel.parentpoller import ParentPollerUnix, ParentPollerWindows
from jupyter_client.session import (
Session, session_flags, session_aliases,
)
from ipykernel.zmqshell import ZMQInteractiveShell
#-----------------------------------------------------------------------------
# Flags and Aliases
#-----------------------------------------------------------------------------
kernel_aliases = dict(base_aliases)
kernel_aliases.update({
'ip' : 'YAPKernelApp.ip',
'hb' : 'YAPKernelApp.hb_port',
'shell' : 'YAPKernelApp.shell_port',
'iopub' : 'YAPKernelApp.iopub_port',
'stdin' : 'YAPKernelApp.stdin_port',
'control' : 'YAPKernelApp.control_port',
'f' : 'YAPKernelApp.connection_file',
'transport': 'YAPKernelApp.transport',
})
kernel_flags = dict(base_flags)
kernel_flags.update({
'no-stdout' : (
{'YAPKernelApp' : {'no_stdout' : True}},
"redirect stdout to the null device"),
'no-stderr' : (
{'YAPKernelApp' : {'no_stderr' : True}},
"redirect stderr to the null device"),
'pylab' : (
{'YAPKernelApp' : {'pylab' : 'auto'}},
"""Pre-load matplotlib and numpy for interactive use with
the default matplotlib backend."""),
})
# inherit flags&aliases for any IPython shell apps
kernel_aliases.update(shell_aliases)
kernel_flags.update(shell_flags)
# inherit flags&aliases for Sessions
kernel_aliases.update(session_aliases)
kernel_flags.update(session_flags)
_ctrl_c_message = """\
NOTE: When using the `ipython kernel` entry point, Ctrl-C will not work.
To exit, you will have to explicitly quit this process, by either sending
"quit" from a client, or using Ctrl-\\ in UNIX-like environments.
To read more about this, see https://github.com/ipython/ipython/issues/2049
"""
#-----------------------------------------------------------------------------
# Application class for starting an IPython Kernel
#-----------------------------------------------------------------------------
class YAPKernelApp(BaseIPythonApplication, InteractiveShellApp,
ConnectionFileMixin):
name='YAP-kernel'
aliases = Dict(kernel_aliases)
flags = Dict(kernel_flags)
classes = [YAPKernel, ZMQInteractiveShell, ProfileDir, Session]
# the kernel class, as an importstring
kernel_class = Type('yap_kernel.yap_kernel.YAPKernel',
klass='ipykernel.kernelbase.Kernel',
help="""The Kernel subclass to be used.
This should allow easy re-use of the IPKernelApp entry point
to configure and launch kernels other than IPython's own.
""").tag(config=True)
kernel = Any()
poller = Any() # don't restrict this even though current pollers are all Threads
heartbeat = Instance(Heartbeat, allow_none=True)
ports = Dict()
subcommands = {
'install': (
'.kernelspec.InstallYAPKernelSpecApp',
'Install the YAP kernel'
),
}
# connection info:
connection_dir = Unicode()
@default('connection_dir')
def _default_connection_dir(self):
return jupyter_runtime_dir()
@property
def abs_connection_file(self):
if os.path.basename(self.connection_file) == self.connection_file:
return os.path.join(self.connection_dir, self.connection_file)
else:
return self.connection_file
# streams, etc.
no_stdout = Bool(False, help="redirect stdout to the null device").tag(config=True)
no_stderr = Bool(False, help="redirect stderr to the null device").tag(config=True)
outstream_class = DottedObjectName('ipykernel.iostream.OutStream',
help="The importstring for the OutStream factory").tag(config=True)
displayhook_class = DottedObjectName('ipykernel.displayhook.ZMQDisplayHook',
help="The importstring for the DisplayHook factory").tag(config=True)
# polling
parent_handle = Integer(int(os.environ.get('JPY_PARENT_PID') or 0),
help="""kill this process if its parent dies. On Windows, the argument
specifies the HANDLE of the parent process, otherwise it is simply boolean.
""").tag(config=True)
interrupt = Integer(int(os.environ.get('JPY_INTERRUPT_EVENT') or 0),
help="""ONLY USED ON WINDOWS
Interrupt this process when the parent is signaled.
""").tag(config=True)
def init_crash_handler(self):
sys.excepthook = self.excepthook
def excepthook(self, etype, evalue, tb):
# write uncaught traceback to 'real' stderr, not zmq-forwarder
traceback.print_exception(etype, evalue, tb, file=sys.__stderr__)
def init_poller(self):
if sys.platform == 'win32':
if self.interrupt or self.parent_handle:
self.poller = ParentPollerWindows(self.interrupt, self.parent_handle)
elif self.parent_handle:
self.poller = ParentPollerUnix()
def _bind_socket(self, s, port):
iface = '%s://%s' % (self.transport, self.ip)
if self.transport == 'tcp':
if port <= 0:
port = s.bind_to_random_port(iface)
else:
s.bind("tcp://%s:%i" % (self.ip, port))
elif self.transport == 'ipc':
if port <= 0:
port = 1
path = "%s-%i" % (self.ip, port)
while os.path.exists(path):
port = port + 1
path = "%s-%i" % (self.ip, port)
else:
path = "%s-%i" % (self.ip, port)
s.bind("ipc://%s" % path)
return port
def write_connection_file(self):
"""write connection info to JSON file"""
cf = self.abs_connection_file
self.log.debug("Writing connection file: %s", cf)
write_connection_file(cf, ip=self.ip, key=self.session.key, transport=self.transport,
shell_port=self.shell_port, stdin_port=self.stdin_port, hb_port=self.hb_port,
iopub_port=self.iopub_port, control_port=self.control_port)
def cleanup_connection_file(self):
cf = self.abs_connection_file
self.log.debug("Cleaning up connection file: %s", cf)
try:
os.remove(cf)
except (IOError, OSError):
pass
self.cleanup_ipc_files()
def init_connection_file(self):
if not self.connection_file:
self.connection_file = "kernel-%s.json"%os.getpid()
try:
self.connection_file = filefind(self.connection_file, ['.', self.connection_dir])
except IOError:
self.log.debug("Connection file not found: %s", self.connection_file)
# This means I own it, and I'll create it in this directory:
ensure_dir_exists(os.path.dirname(self.abs_connection_file), 0o700)
# Also, I will clean it up:
atexit.register(self.cleanup_connection_file)
return
try:
self.load_connection_file()
except Exception:
self.log.error("Failed to load connection file: %r", self.connection_file, exc_info=True)
self.exit(1)
def init_sockets(self):
# Create a context, a session, and the kernel sockets.
self.log.info("Starting the kernel at pid: %i", os.getpid())
context = zmq.Context.instance()
# Uncomment this to try closing the context.
# atexit.register(context.term)
self.shell_socket = context.socket(zmq.ROUTER)
self.shell_socket.linger = 1000
self.shell_port = self._bind_socket(self.shell_socket, self.shell_port)
self.log.debug("shell ROUTER Channel on port: %i" % self.shell_port)
self.stdin_socket = context.socket(zmq.ROUTER)
self.stdin_socket.linger = 1000
self.stdin_port = self._bind_socket(self.stdin_socket, self.stdin_port)
self.log.debug("stdin ROUTER Channel on port: %i" % self.stdin_port)
self.control_socket = context.socket(zmq.ROUTER)
self.control_socket.linger = 1000
self.control_port = self._bind_socket(self.control_socket, self.control_port)
self.log.debug("control ROUTER Channel on port: %i" % self.control_port)
self.init_iopub(context)
def init_iopub(self, context):
self.iopub_socket = context.socket(zmq.PUB)
self.iopub_socket.linger = 1000
self.iopub_port = self._bind_socket(self.iopub_socket, self.iopub_port)
self.log.debug("iopub PUB Channel on port: %i" % self.iopub_port)
self.configure_tornado_logger()
self.iopub_thread = IOPubThread(self.iopub_socket, pipe=True)
self.iopub_thread.start()
# backward-compat: wrap iopub socket API in background thread
self.iopub_socket = self.iopub_thread.background_socket
def init_heartbeat(self):
"""start the heart beating"""
# heartbeat doesn't share context, because it mustn't be blocked
# by the GIL, which is accessed by libzmq when freeing zero-copy messages
hb_ctx = zmq.Context()
self.heartbeat = Heartbeat(hb_ctx, (self.transport, self.ip, self.hb_port))
self.hb_port = self.heartbeat.port
self.log.debug("Heartbeat REP Channel on port: %i" % self.hb_port)
self.heartbeat.start()
def log_connection_info(self):
"""display connection info, and store ports"""
basename = os.path.basename(self.connection_file)
if basename == self.connection_file or \
os.path.dirname(self.connection_file) == self.connection_dir:
# use shortname
tail = basename
else:
tail = self.connection_file
lines = [
"To connect another client to this kernel, use:",
" --existing %s" % tail,
]
# log connection info
# info-level, so often not shown.
# frontends should use the %connect_info magic
# to see the connection info
for line in lines:
self.log.info(line)
# also raw print to the terminal if no parent_handle (`ipython kernel`)
# unless log-level is CRITICAL (--quiet)
if not self.parent_handle and self.log_level < logging.CRITICAL:
io.rprint(_ctrl_c_message)
for line in lines:
io.rprint(line)
self.ports = dict(shell=self.shell_port, iopub=self.iopub_port,
stdin=self.stdin_port, hb=self.hb_port,
control=self.control_port)
def init_blackhole(self):
"""redirects stdout/stderr to devnull if necessary"""
if self.no_stdout or self.no_stderr:
blackhole = open(os.devnull, 'w')
if self.no_stdout:
sys.stdout = sys.__stdout__ = blackhole
if self.no_stderr:
sys.stderr = sys.__stderr__ = blackhole
def init_io(self):
"""Redirect input streams and set a display hook."""
if self.outstream_class:
outstream_factory = import_item(str(self.outstream_class))
sys.stdout = outstream_factory(self.session, self.iopub_thread, u'stdout')
sys.stderr = outstream_factory(self.session, self.iopub_thread, u'stderr')
if self.displayhook_class:
displayhook_factory = import_item(str(self.displayhook_class))
self.displayhook = displayhook_factory(self.session, self.iopub_socket)
sys.displayhook = self.displayhook
self.patch_io()
def patch_io(self):
"""Patch important libraries that can't handle sys.stdout forwarding"""
try:
import faulthandler
except ImportError:
pass
else:
# Warning: this is a monkeypatch of `faulthandler.enable`, watch for possible
# updates to the upstream API and update accordingly (up-to-date as of Python 3.5):
# https://docs.python.org/3/library/faulthandler.html#faulthandler.enable
# change default file to __stderr__ from forwarded stderr
faulthandler_enable = faulthandler.enable
def enable(file=sys.__stderr__, all_threads=True, **kwargs):
return faulthandler_enable(file=file, all_threads=all_threads, **kwargs)
faulthandler.enable = enable
if hasattr(faulthandler, 'register'):
faulthandler_register = faulthandler.register
def register(signum, file=sys.__stderr__, all_threads=True, chain=False, **kwargs):
return faulthandler_register(signum, file=file, all_threads=all_threads,
chain=chain, **kwargs)
faulthandler.register = register
def init_signal(self):
signal.signal(signal.SIGINT, signal.SIG_IGN)
def init_kernel(self):
"""Create the Kernel object itself"""
shell_stream = ZMQStream(self.shell_socket)
control_stream = ZMQStream(self.control_socket)
kernel_factory = self.kernel_class.instance
kernel = kernel_factory(parent=self, session=self.session,
shell_streams=[shell_stream, control_stream],
iopub_thread=self.iopub_thread,
iopub_socket=self.iopub_socket,
stdin_socket=self.stdin_socket,
log=self.log,
profile_dir=self.profile_dir,
user_ns=self.user_ns,
)
kernel.record_ports({
name + '_port': port for name, port in self.ports.items()
})
self.kernel = kernel
# Allow the displayhook to get the execution count
self.displayhook.get_execution_count = lambda: kernel.execution_count
def init_gui_pylab(self):
"""Enable GUI event loop integration, taking pylab into account."""
# Register inline backend as default
# this is higher priority than matplotlibrc,
# but lower priority than anything else (mpl.use() for instance).
# This only affects matplotlib >= 1.5
if not os.environ.get('MPLBACKEND'):
os.environ['MPLBACKEND'] = 'module://ipykernel.pylab.backend_inline'
# Provide a wrapper for :meth:`InteractiveShellApp.init_gui_pylab`
# to ensure that any exception is printed straight to stderr.
# Normally _showtraceback associates the reply with an execution,
# which means frontends will never draw it, as this exception
# is not associated with any execute request.
shell = self.shell
_showtraceback = shell._showtraceback
try:
# replace error-sending traceback with stderr
def print_tb(etype, evalue, stb):
print ("GUI event loop or pylab initialization failed",
file=sys.stderr)
print (shell.InteractiveTB.stb2text(stb), file=sys.stderr)
shell._showtraceback = print_tb
InteractiveShellApp.init_gui_pylab(self)
finally:
shell._showtraceback = _showtraceback
def init_shell(self):
self.shell = getattr(self.kernel, 'shell', None)
if self.shell:
self.shell.configurables.append(self)
def init_extensions(self):
super(YAPKernelApp, self).init_extensions()
# BEGIN HARDCODED WIDGETS HACK
# Ensure ipywidgets extension is loaded if available
extension_man = self.shell.extension_manager
if 'ipywidgets' not in extension_man.loaded:
try:
extension_man.load_extension('ipywidgets')
except ImportError as e:
self.log.debug('ipywidgets package not installed. Widgets will not be available.')
# END HARDCODED WIDGETS HACK
def configure_tornado_logger(self):
""" Configure the tornado logging.Logger.
Must set up the tornado logger or else tornado will call
basicConfig for the root logger which makes the root logger
go to the real sys.stderr instead of the capture streams.
This function mimics the setup of logging.basicConfig.
"""
logger = logging.getLogger('tornado')
handler = logging.StreamHandler()
formatter = logging.Formatter(logging.BASIC_FORMAT)
handler.setFormatter(formatter)
logger.addHandler(handler)
@catch_config_error
def initialize(self, argv=None):
super(YAPKernelApp, self).initialize(argv)
if self.subapp is not None:
return
# register zmq IOLoop with tornado
zmq_ioloop.install()
self.init_blackhole()
self.init_connection_file()
self.init_poller()
self.init_sockets()
self.init_heartbeat()
# writing/displaying connection info must be *after* init_sockets/heartbeat
self.write_connection_file()
# Log connection info after writing connection file, so that the connection
# file is definitely available at the time someone reads the log.
self.log_connection_info()
self.init_io()
self.init_signal()
self.init_kernel()
# shell init steps
self.init_path()
self.init_shell()
if self.shell:
self.init_gui_pylab()
self.init_extensions()
self.init_code()
# flush stdout/stderr, so that anything written to these streams during
# initialization do not get associated with the first execution request
sys.stdout.flush()
sys.stderr.flush()
def start(self):
if self.subapp is not None:
return self.subapp.start()
if self.poller is not None:
self.poller.start()
self.kernel.start()
try:
ioloop.IOLoop.instance().start()
except KeyboardInterrupt:
pass
launch_new_instance = YAPKernelApp.launch_instance
def main():
"""Run an IPKernel as an application"""
app = YAPKernelApp.instance()
app.initialize()
app.start()
if __name__ == '__main__':
main()

View File

@ -0,0 +1,188 @@
"""The IPython kernel spec for Jupyter"""
# Copyright (c) IPython Development Team.
# Distributed under the terms of the Modified BSD License.
from __future__ import print_function
import errno
import json
import os
import shutil
import sys
import tempfile
from jupyter_client.kernelspec import KernelSpecManager
pjoin = os.path.join
KERNEL_NAME = 'YAP%i' % sys.version_info[0]
# path to kernelspec resources
RESOURCES = pjoin(os.path.dirname(__file__), 'resources')
def make_ipkernel_cmd(mod='ipykernel', executable=None, extra_arguments=None, **kw):
"""Build Popen command list for launching an IPython kernel.
Parameters
----------
mod : str, optional (default 'ipykernel')
A string of an IPython module whose __main__ starts an IPython kernel
executable : str, optional (default sys.executable)
The Python executable to use for the kernel process.
extra_arguments : list, optional
A list of extra arguments to pass when executing the launch code.
Returns
-------
A Popen command list
"""
if executable is None:
executable = sys.executable
extra_arguments = extra_arguments or []
arguments = [executable, '-m', mod, '-f', '{connection_file}']
arguments.extend(extra_arguments)
return arguments
def get_kernel_dict(extra_arguments=None):
"""Construct dict for kernel.json"""
return {
'argv': make_ipkernel_cmd(extra_arguments=extra_arguments),
'display_name': 'Python %i' % sys.version_info[0],
'language': 'python',
}
def write_kernel_spec(path=None, overrides=None, extra_arguments=None):
"""Write a kernel spec directory to `path`
If `path` is not specified, a temporary directory is created.
If `overrides` is given, the kernelspec JSON is updated before writing.
The path to the kernelspec is always returned.
"""
if path is None:
path = os.path.join(tempfile.mkdtemp(suffix='_kernels'), KERNEL_NAME)
# stage resources
shutil.copytree(RESOURCES, path)
# write kernel.json
kernel_dict = get_kernel_dict(extra_arguments)
if overrides:
kernel_dict.update(overrides)
with open(pjoin(path, 'kernel.json'), 'w') as f:
json.dump(kernel_dict, f, indent=1)
return path
def install(kernel_spec_manager=None, user=False, kernel_name=KERNEL_NAME, display_name=None,
prefix=None, profile=None):
"""Install the IPython kernelspec for Jupyter
Parameters
----------
kernel_spec_manager: KernelSpecManager [optional]
A KernelSpecManager to use for installation.
If none provided, a default instance will be created.
user: bool [default: False]
Whether to do a user-only install, or system-wide.
kernel_name: str, optional
Specify a name for the kernelspec.
This is needed for having multiple IPython kernels for different environments.
display_name: str, optional
Specify the display name for the kernelspec
profile: str, optional
Specify a custom profile to be loaded by the kernel.
prefix: str, optional
Specify an install prefix for the kernelspec.
This is needed to install into a non-default location, such as a conda/virtual-env.
Returns
-------
The path where the kernelspec was installed.
"""
if kernel_spec_manager is None:
kernel_spec_manager = KernelSpecManager()
if (kernel_name != KERNEL_NAME) and (display_name is None):
# kernel_name is specified and display_name is not
# default display_name to kernel_name
display_name = kernel_name
overrides = {}
if display_name:
overrides["display_name"] = display_name
if profile:
extra_arguments = ["--profile", profile]
if not display_name:
# add the profile to the default display name
overrides["display_name"] = 'Python %i [profile=%s]' % (sys.version_info[0], profile)
else:
extra_arguments = None
path = write_kernel_spec(overrides=overrides, extra_arguments=extra_arguments)
dest = kernel_spec_manager.install_kernel_spec(
path, kernel_name=kernel_name, user=user, prefix=prefix)
# cleanup afterward
shutil.rmtree(path)
return dest
# Entrypoint
from traitlets.config import Application
class InstallYAPKernelSpecApp(Application):
"""Dummy app wrapping argparse"""
name = 'ipython-kernel-install'
def initialize(self, argv=None):
if argv is None:
argv = sys.argv[1:]
self.argv = argv
def start(self):
import argparse
parser = argparse.ArgumentParser(prog=self.name,
description="Install the YAP kernel spec.")
parser.add_argument('--user', action='store_true',
help="Install for the current user instead of system-wide")
parser.add_argument('--name', type=str, default=KERNEL_NAME,
help="Specify a name for the kernelspec."
" This is needed to have multiple IPython kernels at the same time.")
parser.add_argument('--display-name', type=str,
help="Specify the display name for the kernelspec."
" This is helpful when you have multiple IPython kernels.")
parser.add_argument('--profile', type=str,
help="Specify an IPython profile to load. "
"This can be used to create custom versions of the kernel.")
parser.add_argument('--prefix', type=str,
help="Specify an install prefix for the kernelspec."
" This is needed to install into a non-default location, such as a conda/virtual-env.")
parser.add_argument('--sys-prefix', action='store_const', const=sys.prefix, dest='prefix',
help="Install to Python's sys.prefix."
" Shorthand for --prefix='%s'. For use in conda/virtual-envs." % sys.prefix)
opts = parser.parse_args(self.argv)
try:
dest = install(user=opts.user, kernel_name=opts.name, profile=opts.profile,
prefix=opts.prefix, display_name=opts.display_name)
except OSError as e:
if e.errno == errno.EACCES:
print(e, file=sys.stderr)
if opts.user:
print("Perhaps you want `sudo` or `--user`?", file=sys.stderr)
self.exit(1)
raise
print("Installed kernelspec %s in %s" % (opts.name, dest))
if __name__ == '__main__':
InstallYAPKernelSpecApp.launch_instance()

View File

@ -1,60 +1,81 @@
from distutils.command.install import install #!/usr/bin/env python
from distutils.core import setup # coding: utf-8
from distutils import log
import json # Copyright (c) IPython Development Team.
# Distributed under the terms of the Modified BSD License.
from __future__ import print_function
# the name of the package
name = 'yap_kernel'
#-----------------------------------------------------------------------------
# Minimal Python version sanity check
#-----------------------------------------------------------------------------
import sys import sys
v = sys.version_info
if v[:2] < (2,7) or (v[0] >= 3 and v[:2] < (3,3)):
error = "ERROR: %s requires Python version 2.7 or 3.3 or above." % name
print(error, file=sys.stderr)
sys.exit(1)
PY3 = (sys.version_info[0] >= 3)
#-----------------------------------------------------------------------------
# get on with it
#-----------------------------------------------------------------------------
import os import os
from glob import glob
PY3 = sys.version_info[0] >= 3 from distutils.core import setup
kernel_json = { packages = ["${CMAKE_CURRENT_SOURCE_DIR}"]
"argv": [sys.executable,
"-m", "yap_kernel", version_ns = {}
"-f", "{connection_file}"], setup_args = dict(
"display_name": " YAP-6.3" , name = 'yap_kernel',
"language": "prolog", version = '0.0.1',
"name": "yap_kernel", packages = ["yap_kernel"],
package_dir = {'': '${CMAKE_SOURCE_DIR}/packages/python' },
description = "YAP Kernel for Jupyter",
long_description="A simple YAP kernel for Jupyter/IPython",
url="https://github.com/vscosta/yap-6.3",
author='Vitor Santos Costa, based on the the IPython',
author_email='vsc@dcc.fc.up.pt',
license = 'BSD',
platforms = "Linux, Mac OS X, Windows",
keywords = ['Interactive', 'Interpreter', 'Shell', 'Web'],
classifiers = [
'Intended Audience :: Developers',
'Intended Audience :: System Administrators',
'Intended Audience :: Science/Research',
'License :: OSI Approved :: BSD License',
'Programming Language :: Prolog',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
],
)
if 'develop' in sys.argv or any(a.startswith('bdist') for a in sys.argv):
import setuptools
setuptools_args = {}
install_requires = setuptools_args['install_requires'] = [
'ipython>=4.0.0',
'traitlets>=4.1.0',
'jupyter_client',
'tornado>=4.0',
]
extras_require = setuptools_args['extras_require'] = {
'test:python_version=="2.7"': ['mock', 'nose_warnings_filters'],
} }
if 'setuptools' in sys.modules:
setup_args.update(setuptools_args)
class install_with_kernelspec(install): if __name__ == '__main__':
def run(self): setup(**setup_args)
install.run(self)
from jupyter_client.kernelspec import install_kernel_spec
from IPython.utils.tempdir import TemporaryDirectory
with TemporaryDirectory() as td:
os.chmod(td, 0o755) # Starts off as 700, not user readable
with open(os.path.join(td, 'kernel.json'), 'w') as f:
json.dump(kernel_json, f, sort_keys=True)
log.info('Installing kernel spec')
try:
install_kernel_spec(td, 'yap_kernel', user=self.user,
replace=True)
except:
install_kernel_spec(td, 'yap_kernel', user=not self.user,
replace=True)
svem_flag = '--single-version-externally-managed'
if svem_flag in sys.argv:
# Die, setuptools, die.
sys.argv.remove(svem_flag)
setup(name='yap_kernel',
version='0.0.1',
package_dir = {'': '${CMAKE_SOURCE_DIR}/packages/python/yap_kernel' },
description='A simple YAP kernel for Jupyter/IPython',
long_description="A simple YAP kernel for Jupyter/IPython, based on MetaKernel",
url="https://github.com/vscosta/yap-6.3",
author='Vitor Santos Costa, based on the metakernel from Douglas Blank',
author_email='vsc@dcc.fc.up.pt',
py_modules=['yap_kernel'],
install_requires=["metakernel","yap"],
cmdclass={'install': install_with_kernelspec},
classifiers = [
'Framework :: IPython',
'License :: OSI Approved :: BSD License',
'Programming Language :: YAP :: 6.3',
'Programming Language :: Python :: 3',
'Topic :: System :: Shells',
]
)

View File

@ -1,44 +1,59 @@
from __future__ import print_function from __future__ import print_function
from metakernel import MetaKernel from ipykernel.ipkernel import IPythonKernel
import sys import sys
import signal import signal
import yap import yap
import yapex
import ipywidgets as widgets import logging
logger = logging.getLogger()
handler = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
logger.debug('often makes a very good meal of %s', 'visiting tourists')
kernel_json = {
"argv": [sys.executable,
"-m", "yap_kernel",
"-f", "{connection_file}"],
"display_name": " YAP-6.3" ,
"language": "prolog",
"name": "yap_kernel",
}
def eprint(*args, **kwargs): def eprint(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs) print(*args, file=sys.stderr, **kwargs)
class YAPKernel(IPythonKernel):
class MetaKernelyap(MetaKernel):
implementation = 'MetaKernel YAP' implementation = 'MetaKernel YAP'
implementation_version = '1.0' implementation_version = '1.0'
language = 'text' language = 'text'
language_version = '0.1' language_version = '0.1'
banner = "MetaKernel YAP" banner = "YAP-6.3"
language_info = { language_info = {
'mimetype': 'text/prolog', 'mimetype': 'text/prolog',
'name': 'text', 'name': 'text',
# ------ If different from 'language': # ------ If different from 'language':
'codemirror_mode': { 'codemirror_mode': {
"version": 2, "version": 2,
"name": "prolog" "name": "prolog"
}, },
'pygments_lexer': 'prolog', 'pygments_lexer': 'prolog',
'version' : "0.0.1", 'version' : "0.0.1",
'file_extension': '.yap', 'file_extension': '.yap',
'help_links': MetaKernel.help_links,
} }
def __init__(self, **kwargs): def __init__(self, **kwargs):
MetaKernel.__init__(self, **kwargs) super(YAPKernel, self).__init__( **kwargs)
self._start_yap(**kwargs) _start_yap( **kwargs )
self.olines = ""
self.ask = True
def _start_yap(self, **kwargs): def _start_yap(self, **kwargs):
# Signal handlers are inherited by forked processes, and we can't easily # Signal handlers are inherited by forked processes, and we can't easily
@ -51,18 +66,16 @@ class MetaKernelyap(MetaKernel):
self.q = None self.q = None
self.engine.query("load_files(library(python), [])").command() self.engine.query("load_files(library(python), [])").command()
self.engine.query("load_files(library(jupyter), [])").command() self.engine.query("load_files(library(jupyter), [])").command()
banner = "YAP {0} Kernel".format(self.engine.version()) banner = "YAP6-3 Kernel"
self.olines = banner self.olines = banner
finally: finally:
signal.signal(signal.SIGINT, sig) signal.signal(signal.SIGINT, sig)
# Register Yap function to write image data to temporary file
#self.yapwrapper.run_command(image_setup_cmd)
def get_usage(self): def get_usage(self):
return "This is the YAP kernel." return "This is the YAP kernel."
def query_prolog(self, s):
def run_cell(self, s, store_history=False, silent=False, shell_futures=True):
if not self.q: if not self.q:
self.q = self.engine.query(s) self.q = self.engine.query(s)
@ -94,118 +107,3 @@ class MetaKernelyap(MetaKernel):
if self.q: if self.q:
self.q.close() self.q.close()
self.q = None self.q = None
def do_execute_direct(self, code):
if not code.strip():
return ""
lines = code.split("\n")
interrupted = False
self.doReset = True
nlines = ""
try:
for line in lines:
line = line.strip()
if line.startswith('#'):
# wait
print( "comment")
elif line.startswith('%'):
# wait
call_magic( line )
elif line.endswith(';'):
nlines += line.rstrip(';').rstrip()
self.doReset = False
break
elif line.endswith('!'):
nlines += line.rstrip('!').rstrip()
self.ask = False
self.doReset = False
break
else:
line = line.rstrip()
if line:
nlines += line + "\n"
if nlines != self.olines:
self.closeq( )
self.olines = nlines
elif self.doReset:
opt = widgets.ToggleButtons(
description='Query Solutions:',
options=['First', 'Next', 'All'],
)
print( opt )
if opt == 'First':
self.closeq( )
elif opt == 'Next':
self.doReset = False
else:
self.ask = False
self.doReset = False
self.query_prolog( nlines )
while not self.ask and self.q:
self.query_prolog( nlines )
except SyntaxError as err:
print("Syntax Error error: {0}".format(err))
except EOFError:
return
except RuntimeError as err:
print("YAP Execution Error: {0}".format(err))
except ValueError:
print("Could not convert data to an integer.")
except KeyboardInterrupt:
return 'stopped by user'
except:
print("Unexpected error:", sys.exc_info()[0])
raise
def do_complete(self, code, cursor_pos):
print(code)
print(cursor_pos)
eprint( code, " -- ", str(cursor_pos ) )
# code = code[:cursor_pos]
# default = {'matches': [], 'cursor_start': 0,
# 'cursor_end': cursor_pos, 'metadata': dict(),
# 'status': 'ok'}
# if not code or code[-1] == ' ':
# return default
# tokens = code.replace(';', ' ').split()
# if not tokens:
# return default
# matches = []
# token = tokens[-1]
# start = cursor_pos - len(token)
# if token[0] == '$':
# # complete variables
# cmd = 'compgen -A arrayvar -A export \
# -A variable %s' % token[1:] # strip leading $
# output = self.bashwrapper.run_command(cmd).rstrip()
# completions = set(output.split())
# # append matches including leading $
# matches.extend(['$'+c for c in completions])
# else:
# # complete functions and builtins
# cmd = 'compgen -cdfa %s' % token
# output = self.bashwrapper.run_command(cmd).rstrip()
# matches.extend(output.split())
# if not matches:
# return default
# matches = [m for m in matches if m.startswith(token)]
# return {'matches': sorted(matches), 'cursor_start': start,
# 'cursor_end': cursor_pos, 'metadata': dict(),
# 'status': 'ok'}
def repr(self, data):
return repr(data)
if __name__ == '__main__':
try:
from ipykernel.kernelapp import IPKernelApp
except ImportError:
from jupyter_client.zmq.kernelapp import IPKernelApp
IPKernelApp.launch_instance(kernel_class=MetaKernelyap)

View File

@ -19,6 +19,7 @@ if (PYTHONLIBS_FOUND)
SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTY SWIG_MODULE_NAME libPy2YAP ) SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTY SWIG_MODULE_NAME libPy2YAP )
configure_file ("setup.py.cmake" "setup.py" ) configure_file ("setup.py.cmake" "setup.py" )
configure_file ("../yap.i" "yap.i" )
#SET( CMAKE_SWIG_OUTDIR "yap" ) #SET( CMAKE_SWIG_OUTDIR "yap" )

View File

@ -11,12 +11,12 @@ else:
setup( setup(
name = "yap", name = "yap",
version = "0.1", version = "0.1",
ext_modules=[Extension('_yap', ['${CMAKE_SOURCE_DIR}/packages/swig/yap.i'], ext_modules=[Extension('_yap', ['yap.i'],
define_macros = [('MAJOR_VERSION', '1'), define_macros = [('MAJOR_VERSION', '1'),
('MINOR_VERSION', '0'), ('MINOR_VERSION', '0'),
('_YAP_NOT_INSTALLED_', '1')], ('_YAP_NOT_INSTALLED_', '1')],
runtime_library_dirs=['${dlls}'], runtime_library_dirs=['${dlls}'],
swig_opts=['-modern', '-c++', '-py3','-I${CMAKE_SOURCE_DIR}/CXX'], swig_opts=['-modern','-outcurrentdir', '-c++', '-py3','-I${CMAKE_SOURCE_DIR}/CXX'],
library_dirs=['../../..','../../../CXX', library_dirs=['../../..','../../../CXX',
'../../python', '../../python',
'.'], '.'],