Sather Runtime ModelProgrammer's InterfaceIn this section, we describe what ANTLR generates after reading your grammar file and how to use that output to parse input. The classes from which your lexer, token, and parser classes are derived are provided as well. What ANTLR generatesANTLR generates the following types of files, where MY_PARSER, MY_LEXER, and MY_TREE_PARSER are names of grammar classes specified in the grammar file. You may have an arbitrary number of parsers, lexers, and tree-parsers per grammar file; a separate class file will be generated for each. In addition, token type files will be generated containing the token vocabularies used in the parsers and lexers. One or more token vocabularies may be defined in a grammar file, and shared between different grammars. For example, given the grammar file: options { language="Sather"; } class MyParser extends Parser; options { exportVocab=MY; } ... rules ... class MY_LEXER extends Lexer; options { exportVocab=MY; } ... rules ... class MY_TREE_PARSER extends TreeParser; options { exportVocab=MY; } ... rules ... The following files will be generated:
The programmer uses the classes by referring to them:
If your parser generates an AST, then get the AST value, create a tree-parser, and invoke one of the tree-parser rules using the AST. lex ::= #MY_LEXER{ANTLR_COMMON_TOKEN}( file_stream ); parser ::= MY_PARSER{ANTLR_COMMON_TOKEN,ANTLR_COMMON_AST}( lex, user-defined-args-if-any ); parser.start-rule; -- and, if you are tree parsing the result... tree_parser ::= #MY_TREE_PARSER{ANTLR_COMMON_AST}; tree_parser.start-rule( parser.ast ); The lexer and parser can cause exceptions of type $ANTLR_RECOGNITION_EXCEPTIONS, which you may catch: lexer ::= #CALC_LEXER{ANTLR_COMMON_TOKEN}( file_stream ); parser ::= #CALC_PARSER{ANTLR_COMMON_TOKEN,ANTLR_COMMON_AST}(lexer); -- Parse the input expression protect parser.expr; when $ANTLR_RECOGNITION_EXCEPTION #ERR + exception.str + "\n"; end; Multiple Lexers/Parsers With Shared Input StateOccasionally, you will want two parsers or two lexers to share input state; that is, you will want them to pull input from the same source token stream or character stream. ANTLR 2.6.0 factored the input variables such as line number, guessing state, input
stream, etc... into a separate object so that another lexer or parser could same that
state. The -- create a Java lexer main_lexer ::= #JAVA_LEXER{ANTLR_COMMON_TOKEN}( input ); -- create javadoc lexer -- attach to shared input state of java lexer doclexer ::= #JAVADOC_LEXER{ANTLR_COMMON_TOKEN}( main_lexer.input_state ); Parsers with shared input state can be created similarly: jdocparser ::= #JAVA_DOC_PARSER{ANTLR_COMMON_TOKEN,ANTLR_COMMON_AST}( input_state ); jdocparser.content; -- go parse the comment Sharing state is easy, but what happens upon exception during the execution of the "subparser"? What about syntactic predicate execution? It turns out that invoking a subparser with the same input state is exactly the same as calling another rule in the same parser as far as error handling and syntactic predicate guessing are concerned. If the parser is guessing before the call to the subparser, the subparser must continue guessing, right? Exceptions thrown inside the subparser must exit the subparser and return to enclosing erro handler or syntactic predicate handler. Parser ImplementationParser ClassANTLR generates a parser class (an extension of ANTLR_LLKPARSER) that contains a method for every rule in your grammar. The general format looks like: class MY_PARSER{ TOKEN < $ANTLR_TOKEN, AST < $ANTLR_AST{AST} } is include ANTLR_LLKPARSER{ TOKEN, AST } create -> super_create; include CALC_PARSER_TOKENTYPES; create ( token_buf : ANTLR_TOKEN_BUFFER{TOKEN} , k : INT ) : SAME is res : SAME := super_create( token_buf, k ); res.token_names := sa_token_names; return res; end; create ( token_buf : ANTLR_TOKEN_BUFFER{TOKEN} ) : SAME is return #SAME( token_buf, 1); end; create ( lexer : $ANTLR_TOKEN_STREAM{TOKEN} , k : INT ) : SAME is res : SAME := super_create( lexer, k ); res.token_names := sa_token_names; return res; end; create( lexer : $ANTLR_TOKEN_STREAM{TOKEN} ) : SAME is res : SAME := #SAME( lexer, 1); return res; end; create ( state : ANTLR_PARSER_SHARED_INPUT_STATE{TOKEN} ) : SAME is res : SAME := super_create( state,1); res.token_names := sa_token_names; return res; end; ... -- add your own constructors here... rule-definitions end; Parser MethodsANTLR generates recursive-descent parsers, therefore, every rule in the grammar will result in a method that applies the specified grammatical structure to the input token stream. The general form of a parser method looks like: rule is init-action-if-present if ( lookahead-predicts-production-1 ) then code-to-match-production-1 elsif ( lookahead-predicts-production-2 ) then code-to-match-production-2 ... elsif ( lookahead-predicts-production-n ) then code-to-match-production-n else -- syntax error raise #ANTLR_NO_VIABLE_ALT_EXCEPTION(LT(1)); end; end;This code results from a rule of the form: rule: production-1 | production-2 ... | production-n ; If you have specified arguments and a return type for the rule, the method header changes to: (* generated from: * rule(user-defined-args) * returns return-type : ... ; *) rule( user-defined-args ) : return-type is ... end; Token types are integers and we make heavy use of sets and range comparisons to avoid excessively-long test expressions. EBNF SubrulesSubrules are like unlabeled rules, consequently, the code generated for an EBNF subrule mirrors that generated for a rule. The only difference is induced by the EBNF subrule operators that imply optionality or looping. (...)? optional subrule. The only difference between the code generated for an optional subrule and a rule is that there is no default else-clause to throw an exception--the recognition continues on having ignored the optional subrule. init-action-if-present if ( lookahead-predicts-production-1 ) then code-to-match-production-1 elsif ( lookahead-predicts-production-2 ) then code-to-match-production-2 ... elsif ( lookahead-predicts-production-n ) then code-to-match-production-n end; Not testing the optional paths of optional blocks has the potential to delay the detection of syntax errors. (...)* closure subrule. A closure subrule is like an optional looping subrule, therefore, we wrap the code for a simple subrule in a "forever" loop that exits whenever the lookahead is not consistent with any of the alternative productions. init-action-if-present loop if ( lookahead-predicts-production-1 ) then code-to-match-production-1 elsif ( lookahead-predicts-production-2 ) then code-to-match-production-2 ... elsif ( lookahead-predicts-production-n ) then code-to-match-production-n else break!; end; end; While there is no need to explicity test the lookahead for consistency with the exit path, the grammar analysis phase computes the lookahead of what follows the block. The lookahead of what follows much be disjoint from the lookahead of each alternative otherwise the loop will not know when to terminate. For example, consider the following subrule that is nondeterministic upon token A. ( A | B )* A Upon A, should the loop continue or exit? One must also ask if the loop should even begin. Because you cannot answer these questions with only one symbol of lookahead, the decision is non-LL(1). Not testing the exit paths of closure loops has the potential to delay the detection of syntax errors. As a special case, a closure subrule with one alternative production results in: init-action-if-present loop while!( lookahead-predicts-production-1 ); code-to-match-production-1 end; This special case results in smaller, faster, and more readable code. (...)+ positive closure subrule. A positive closure subrule is a loop around a series of production prediction tests like a closure subrule. However, we must guarantee that at least one iteration of the loop is done before proceeding to the construct beyond the subrule. sa_cnt : INT := 0; init-action-if-present loop if ( lookahead-predicts-production-1 ) then code-to-match-production-1 elsif ( lookahead-predicts-production-2 ) then code-to-match-production-2 ... elsif ( lookahead-predicts-production-n ) then code-to-match-production-n elsif ( sa_cnt>1 ) then -- lookahead predicted nothing and we've -- done an iteration break!; else raise #ANTLR_NO_VIABLE_ALT_EXCEPTION(LT(1)); end; sa_cnt := sa_cnt + 1; -- track times through the loop end; While there is no need to explicity test the lookahead for consistency with the exit path, the grammar analysis phase computes the lookahead of what follows the block. The lookahead of what follows much be disjoint from the lookahead of each alternative otherwise the loop will not know when to terminate. For example, consider the following subrule that is nondeterministic upon token A. ( A | B )+ A Upon A, should the loop continue or exit? Because you cannot answer this with only one symbol of lookahead, the decision is non-LL(1). Not testing the exit paths of closure loops has the potential to delay the detection of syntax errors. You might ask why we do not have a while loop that tests to see if the lookahead is consistent with any of the alternatives (rather than having series of tests inside the loop with a break). It turns out that we can generate smaller code for a series of tests than one big one. Moreover, the individual tests must be done anyway to distinguish between alternatives so a while condition would be redundant. As a special case, if there is only one alternative, the following is generated: init-action-if-present loop code-to-match-production-1 if ( lookahead-predicts-production-1 ) then break!; end; end; Optimization. When there are a large (where large is user-definable) number of strictly LL(1) prediction alternatives, then a case-statement can be used rather than a sequence of if-statements. The non-LL(1) cases are handled by generating the usual if-statements in the else case. For example: case ( LA(1) ) when KEY_WHILE, KEY_IF, KEY_DO then statement; when KEY_INT, KEY_FLOAT then declaration; else -- do whatever else-clause is appropriate end; This optimization relies on the compiler building a more direct jump (via jump table or hash table) to the ith production matching code. This is also more readable and faster than a series of set membership tests. Production PredictionLL(1) prediction. Any LL(1) prediction test is a simple set membership test. If the set is a singleton set (a set with only one element), then an integer token type = comparison is done. If the set degree is greater than one, a set is created and the single input token type is tested for membership against that set. For example, consider the following rule: a : A | b ; b : B | C | D | E | F; The lookahead that predicts production one is {A} and the lookahead that predicts production two is {B,C,D,E,F}. The following code would be generated by ANTLR for rule a (slightly cleaned up for clarity): a is if ( LA(1) = A ) then match(A); elsif ( token_set1.member(LA(1)) ) then b; end; end; The prediction for the first production can be done with a simple integer comparison, but the second alternative uses a set membership test for speed, which you probably didn't recognize as testing LA(1) member {B,C,D,E,F}. The complexity threshold above which set-tests are generated is user-definable. We use arrays of BOOLs to hold sets. The various sets needed by ANTLR are created and initialized in the generated parser (or lexer) class. Approximate LL(k) prediction. An extension of LL(1)...basically we do a series of up to k set tests rather than a single as we do in LL(1) prediction. Each decision will use a different amount of lookahead, with LL(1) being the dominant decision type. Production Element RecognitionToken references. Token references are translated to: match(token-type); For example, a reference to token KEY_BEGIN results in: match(KEY_BEGIN); where KEY_BEGIN will be an integer constant defined in the MY_PARSER_TOKENTYPES class generated by ANTLR. String literal references. String literal references are references to automatically generated tokens to which ANTLR automatically assigns a token type (one for each unique string). String references are translated to: match(T); where T is the token type assigned by ANTLR to that token. Character literal references. Referencing a character literal implies that the current rule is a lexical rule. Single characters, 't', are translated to: match('t'); which can be manually inlined with: if ( c = 't' ) then consume; else raise #ANTLR_NO_VIABLE_ALT_FOR_CHAR_EXCEPTION( LA(1), file_name, line ); end; if the method call proves slow (at the cost of space). Wildcard references. In lexical rules, the wildcard is translated to: consume; which simply gets the next character of input without doing a test. References to the wildcard in a parser rule results in the same thing except that the consume call will be with respect to the parser. Not operator. When operating on a token, ~T is translated to: match_not( T ); When operating on a character literal, 't' is translated to: match_Not( 't' ); Range operator. In parser rules, the range operator (T1..T2) is translated to: match_range( T1, T2 ); In a lexical rule, the range operator for characters c1..c2 is translated to: match_range( c1, c2 ); Labels. Element labels on atom references become TOKENS references in parser rules and INTs in lexical rules. For example, the parser rule: a : id:ID { OUT::create + "id is " + id + '\n'; } ;would be translated to: a is id : TOKEN := void; id := LT(1); match(ID); OUT::create + "id is " + id + '\n'; end;For lexical rules such as: ID : w:. { OUT::create + "w is "+ w + '\n'; } ;the following code would result: ID is w : CHAR; w := c; consume; -- match wildcard (anything) OUT::create + "w is "+ w + '\n'; end; Labels on rule references result in AST references, when generating trees, of the form label_ast. Rule references. Rule references become method calls. Arguments to rules become arguments to the invoked methods. Return values are assigned like Sather assignments. Consider rule reference i=list[1] to rule: list[scope:INT] returns INT : { return scope+3; } ;The rule reference would be translated to: i := list(1); Semantic actions. Actions are translated verbatim to the output parser or lexer except for the translations required for AST generation. To add members to a lexer or parser class definition, add the class member definitions enclosed in {} immediately following the class specification, for example: class MY_PARSER extends Parser; { private i : INT; create ( lexer : ANTLR_TOKEN_STREAM{TOKEN}, aUsefulArgument : INT ) : SAME is i := aUsefulArgument; end; } ... rules ... ANTLR collects everything inside the {...} and inserts it in the class definition before the rule-method definitions. Semantic predicates. Lexer ImplementationLexer FormThe lexers produced by ANTLR 2.x are a lot like the parsers produced by ANTLR 2.x. They only major differences are that (a) scanners use characters instead of tokens, and (b) ANTLR generates a special next_token rule for each scanner which is a production containing each public lexer rule as an alternate. The name of the lexical grammar class provided by the programmer results in a subclass of ANTLR_CHARS_CANNER, for example class MY_LEXER{TOKEN} < $ANTLR_TOKEN_STREAM{TOKEN} , $ANTLR_FILE_CURSOR is include ANTLR_CHAR_SCANNER{TOKEN} create -> private char_scanner_create; include CALC_PARSER_TOKENTYPES; create ( istr : $ISTREAM ) : SAME is ... end; create ( bb : ANTLR_BYTE_BUFFER ) : SAME is ... end; create ( state : ANTLR_LEXER_SHARED_INPUT_STATE ) : SAME is ... end; next_token : TOKEN is scanning logic ... end; recursive and other non-inlined lexical methods ... end; When an ANTLR-generated parser needs another token from its lexer, it calls a method called next_token. The general form of the next_token method is: next_token : TOKEN is ss_ttype : INT; loop protect reset_text; case ( LA(1) ) case for each char predicting lexical rule call lexical rule gets token type -> sa_ttype else raise #ANTLR_NO_VIABLE_ALT_FOR_CHAR_EXCEPTION( LA(1), file_name, line ); end; if ( sa_ttype /= ANTLR_COMMON_TOKEN::SKIP ) then return make_token( sa_ttype ); end; when $ANTLR_RECOGNITION_EXCEPTION then report_error( exception.str ); end; end; end; For example, the lexical rules: class LEX extends Lexer; WS : ('\t' | '\r' | ' ') {sa_ttype := ANTLR_COMMON_TOKEN::SKIP;} ; PLUS : '+'; MINUS: '-'; INT : ( '0'..'9' )+ ; ID : ( 'a'..'z' )+ ; UID : ( 'A'..'Z' )+ ;would result in something like: class LEX{TOKEN} < $ANTLR_TOKEN_STREAM{TOKEN} , $ANTLR_FILE_CURSOR is next_token : TOKEN is sa_rettoken : TOKEN; continue : BOOL := true; loop sa_ttype : INT := ANTLR_COMMON_TOKEN::INVALID_TYPE; reset_text; protect -- for char stream error handling protect -- for lexical error handling case ( LA(1) ) when '\t' , '\r' , ' ' then mWS( true ); sa_rettoken := sa_return_token; when '+' then mPLUS( true ); sa_rettoken := sa_return_token; when '-' then mMINUS( true ); sa_rettoken := sa_return_token; when '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' then mINT( true ); sa_rettoken := sa_return_token; when 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z' then mID( true ); sa_rettoken := sa_return_token; when 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' then mUID( true ); sa_rettoken := sa_return_token; else -- default if ( LA(1) = EOF_CHAR ) then upon_eof; sa_return_token := make_token( ANTLR_COMMON_TOKEN::EOF_TYPE); else raise #ANTLR_NO_VIABLE_ALT_FOR_CHAR_EXCEPTION( LA(1), file_name, line ); end; -- if end; -- case if ( ~void(sa_return_token) and continue ) then; sa_ttype := sa_return_token.ttype; sa_ttype := test_literals_table(sa_ttype); sa_return_token.ttype := sa_ttype; return sa_return_token; end; -- if when $ANTLR_RECOGNITION_EXCEPTION then report_error( exception ); consume; end; -- protect when $ANTLR_CHAR_STREAM_EXCEPTION then raise #ANTLR_TOKEN_STREAM_EXCEPTION( exception.message ); end; -- protect end; -- loop end; -- next_token mWS( sa_create_token : BOOL ) is sa_ttype : INT; sa_token : TOKEN; sa_begin : INT := text.length; sa_ttype := WS; sa_save_index : INT; case ( LA(1) ) when '\t' then match('\t'); when '\r' then match('\r'); when ' ' then match(' '); else raise #ANTLR_NO_VIABLE_ALT_FOR_CHAR_EXCEPTION( LA(1), file_name, line ); end; -- case sa_ttype := ANTLR_COMMON_TOKEN::SKIP; if ( sa_create_token and void(sa_token) and sa_ttype /= ANTLR_COMMON_TOKEN::SKIP ) then sa_token := make_token( sa_ttype ); sa_token.text := text.substring( sa_begin, text.length - sa_begin ); end; -- if sa_return_token := sa_token; end; -- rule mPLUS( sa_create_token : BOOL ) is sa_ttype : INT; sa_token : TOKEN; sa_begin : INT := text.length; sa_ttype := PLUS; sa_save_index : INT; match('+'); if ( sa_create_token and void(sa_token) and sa_ttype /= ANTLR_COMMON_TOKEN::SKIP ) then sa_token := make_token( sa_ttype ); sa_token.text := text.substring( sa_begin, text.length - sa_begin ); end; -- if sa_return_token := sa_token; end; -- rule mMINUS( sa_create_token : BOOL ) is sa_ttype : INT; sa_token : TOKEN; sa_begin : INT := text.length; sa_ttype := MINUS; sa_save_index : INT; match('-'); if ( sa_create_token and void(sa_token) and sa_ttype /= ANTLR_COMMON_TOKEN::SKIP ) then sa_token := make_token( sa_ttype ); sa_token.text := text.substring( sa_begin, text.length - sa_begin ); end; -- if sa_return_token := sa_token; end; -- rule mINT( sa_create_token : BOOL ) is sa_ttype : INT; sa_token : TOKEN; sa_begin : INT := text.length; sa_ttype := INT; sa_save_index : INT; sa0_cnt7 : INT := 0; loop if (((LA(1) >= '0' and LA(1) <= '9'))) then match_range( '0', '9' ); else if ( sa0_cnt7 >= 1 ) then break! else raise #ANTLR_NO_VIABLE_ALT_FOR_CHAR_EXCEPTION( LA(1), file_name, line ); end; -- if end; -- if sa0_cnt7 := sa0_cnt7 + 1; end; -- loop if ( sa_create_token and void(sa_token) and sa_ttype /= ANTLR_COMMON_TOKEN::SKIP ) then sa_token := make_token( sa_ttype ); sa_token.text := text.substring( sa_begin, text.length - sa_begin ); end; -- if sa_return_token := sa_token; end; -- rule mID( sa_create_token : BOOL ) is sa_ttype : INT; sa_token : TOKEN; sa_begin : INT := text.length; sa_ttype := ID; sa_save_index : INT; sa1_cnt10 : INT := 0; loop if (((LA(1) >= 'a' and LA(1) <= 'z'))) then match_range( 'a', 'z' ); else if ( sa1_cnt10 >= 1 ) then break! else raise #ANTLR_NO_VIABLE_ALT_FOR_CHAR_EXCEPTION( LA(1), file_name, line ); end; -- if end; -- if sa1_cnt10 := sa1_cnt10 + 1; end; -- loop if ( sa_create_token and void(sa_token) and sa_ttype /= ANTLR_COMMON_TOKEN::SKIP ) then sa_token := make_token( sa_ttype ); sa_token.text := text.substring( sa_begin, text.length - sa_begin ); end; -- if sa_return_token := sa_token; end; -- rule mUID( sa_create_token : BOOL ) is sa_ttype : INT; sa_token : TOKEN; sa_begin : INT := text.length; sa_ttype := UID; sa_save_index : INT; sa2_cnt13 : INT := 0; loop if (((LA(1) >= 'A' and LA(1) <= 'Z'))) then match_range( 'A', 'Z' ); else if ( sa2_cnt13 >= 1 ) then break! else raise #ANTLR_NO_VIABLE_ALT_FOR_CHAR_EXCEPTION( LA(1), file_name, line ); end; -- if end; -- if sa2_cnt13 := sa2_cnt13 + 1; end; -- loop if ( sa_create_token and void(sa_token) and sa_ttype /= ANTLR_COMMON_TOKEN::SKIP ) then sa_token := make_token( sa_ttype ); sa_token.text := text.substring( sa_begin, text.length - sa_begin ); end; -- if sa_return_token := sa_token; end; -- rule end; -- class ANTLR-generated lexers assume that you will be reading streams of characters. If this is not the case, you must create your own lexer. Creating Your Own LexerTo create your own lexer, your Sather class that will doing the lexing must implement interface $ANTLR_TOKEN_STREAM, which simply states that you must be able to return a stream of tokens conforming to $ANTLR_TOKEN via next_token: abstract class $ANTLR_TOKEN_STREAM{TOKEN < $ANTLR_TOKEN} is next_token : TOKEN; end; ANTLR will not generate a lexer if you do not specify a lexical class. Launching a parser with a non-ANTLR-generated lexer is the same as launching a parser with an ANTLR-generated lexer: lex ::= #HAND_BUILT_LEXER{MY_TOKEN}(...); p ::= #MY_PARSER{MY_TOKEN,ANTLR_COMMON_AST}(lex); p.start-rule; The parser does not care what kind of object you use for scanning as as long as it can answer next_token. If you build your own lexer, and the token values are also generated by that lexer, then you should inform the ANTLR-generated parsers about the token type values generated by that lexer. Use the importVocab in the parsers that use the externally-generated token set, and create a token definition file following the requirements of the importVocab option. Lexical RulesLexical rules are essentially the same as parser rules except that lexical rules apply a structure to a series of characters rather than a series of tokens. As with parser rules, each lexical rule results in a method in the output lexer class. Alternative blocks. Consider a simple series of alternatives within a block: FORMAT : 'x' | 'f' | 'd'; The lexer would contain the following method: mFORMAT is if ( c = 'x' ) then match('x'); elsif ( c = 'x' ) then match('x'); elsif ( c = 'f' ) then match('f'); elsif ( c = 'd' ) then match('d'); else raise #ANTLR_NO_VIABLE_ALT_FOR_CHAR_EXCEPTION( ... ); end; return FORMAT; end; The only real differences between lexical methods and grammar methods are that lookahead prediction expressions do character comparisons rather than LA(i) comparisons, match matches characters instead of tokens, and a return is added to the bottom of the rule. For example, the common identifier rule would be placed directly into the next_token method. That is, rule:ID : ( 'a'..'z' | 'A'..'Z' )+ ; would not result in a method in your lexer class. This rule would become part of the resulting lexer as it would be probably inlined by ANTLR: next_token : TOKEN is case ( LA(1) ) cases for operators and such here -- chars that predict ID token case '0', '1', '2', '3' '4', '5', '6', '7', '8', '9' then loop while!( c > ='0' and c < ='9' ); match_range( '0' , '9' ); end; return make_token(ID); else check harder stuff here like rules beginning with a..z end; If not inlined, the method for scanning identifiers would look like: mID : TOKEN is loop while!( c > = '0' and c < = '9' ) match_range( '0' , '9' ); end; return ID; end; where token names are converted to method names by prefixing them with the letter m. The next_token method would become: next_token : TOKEN is case ( c ) cases for operators and such here -- chars that predict ID token when '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' return make_token( mID ); else check harder stuff here like rules beginning with a..z end; Note that this type of range loop is so common that it should probably be optimized to: loop while! ( c >= '0' and c <= '9' ); consume; end; Optimization: Recursive lexical rules. Lexical rules that are directly or indirectly recursive are not inlined. For example, consider the following rule that matches nested actions: ACTION : '{' ( ACTION | ~'}' )* '}' ; ACTION would be result in (assuming a character vocabulary of 'a'..'z', '{', '}'): mACTION : INT is sa_ttype : INT := ACTION; match('{'); loop case ( LA(1) ) when '{' then mACTION; when 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z' then match_not('}'); else break!; end; end; match('}'); return sa_ttype; end; Version: $Id: //depot/code/org.antlr/release/antlr-2.7.1/doc/sa-runtime.html#1 $ |


{{#contentFor "relativePath"}}../{{/contentFor}} {{!< ../layouts/starter-page.html}} Hello, world! This is a basic starter page with charts. {{> components/examples/billing-summary-4 }} {{> navigation/examples/nav-local }} pie chart line chart line chart bar chart {{> components/examples/activity-history }} {{#contentFor "scripts"}} {{/contentFor}}
This is a basic starter page with charts.
pie chart
line chart
bar chart


The FreeRADIUS Project
Anonymous Git Access
Anonymous git access is available for the following trees, with HTTP access provided via GitHub:- v3.1.x - The next "major" release, which will have new features and other changes.
$ git clone https://github.com/FreeRADIUS/freeradius-server.git $ cd freeradius-server $ git checkout -b v3.1.x origin/v3.1.x
$ git clone https://github.com/FreeRADIUS/freeradius-server.git $ cd freeradius-server $ git checkout -b v3.0.x origin/v3.0.x
$ git clone https://github.com/FreeRADIUS/freeradius-server.git $ cd freeradius-server $ git checkout -b v2.x.x origin/v2.x.x
Followed by the usual
$ ./configure $ make $ make install
The GitHub links above support:
- gitweb access,
- support for cloning via HTTP,
- support for downloading "tar" files of the git tree.
Please read the howto page for the suggested git work flow.
Submitting Patches
See the patch page for instructions
Commit Access
Instructions for core team members are on the commit access page.
Old Git branches
As of June 2010, the old "master" branch has been moved to "old-dev". It contained a line of development which did not work out. Therefore, the old "stable" branch has become the new "master" branch. The old "stable" branch still exists, but should not be used
Anyone who was using the old "master" branch should discard it, and base all of their work on the new "master" branch. Since we discouraged anyone from using the "master" branch, this change should not cause problems for anyone.


when i logged on to erowid; i couldnt believe that there were no reports on oxycontin. It has been a big drug where i live and everyone needs to know about it. I was staying at my boyfriend tim's house, when the friendly neighborhood drug dealer cam in and asked us if we wanted to try some OC's. I bought them from him and immediately popped the pill. In about 10 minutes i started to feel a rush, like on speed.
I asked tim if he wanted to go for a walk somewhere since we were both buzzing around his apartment like crazy. We went for a very brisk walk for about a mile and a half. I started to feel like i was coming down from it so we turned around and went home. When we got there i immediately plopped down on the couch and started having the feeling like i had smoked extremely kind bud and opium. everything was moving slower and was very relaxing; when i closed my eyes there were some cev's and the wah-wah's.
 It's one of my favorites now. There is nothing like it in the world.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Skip to primary content
Skip to main navigation
Search
Bioluminescence
Home
About
Species
Insects
Fungi
Fish
Aquatic Animals
Angler Fish


{% extends "base/base.html" %} {% block title %}Site administration — {{ block.super }}{% endblock %} {% block subtitle %}Site administration{% endblock %} {% block container %} {% if not default_device %}
As a site administrator, please enable two-factor authentication (2FA) for enhanced account security.
Enable two-factor authentication| Company | Title | Type | |
|---|---|---|---|
| {{ job.user.profile.name }} | {{ job.title }} | {{ job.job_type.label }} | {% if job.state.name != "REMOVED" %} View {% endif %} |
| There are no jobs marked as {{ state.label }}. |


--- layout: post status: publish published: true title: Back to the Future author: display_name: Tomas Restrepo login: tomasr email<EMAIL_ADDRESS>url: http://winterdom.com/ author_login: tomasr author_email<EMAIL_ADDRESS>author_url: http://winterdom.com/ wordpress_id: 415 wordpress_url: http://winterdom.com/2007/06/backtothefuture date: '2007-06-12 12:36:17 +0000' date_gmt: '2007-06-12 12:36:17 +0000' categories: - Development - Tools tags: [] comments: [] ---
... or not.


Occasionally when a character is shown to be imprisoned, the spacing between the jail bars is actually wider than the character's body. He could easily walk through the bars and escape, but doesn't, for whatever reason.
This is primarily a cartoon trope. Live-action prison bars are rarely made this way, unless the gag is specifically sending up the cartoon trope. Drawn or rendered bars are spaced that way so that they don't interfere with the view of the character's face and body language. They're visual shorthand for imprisonment, and are not drawn functionally even if we're supposed to believe they work.note
Look out for examples using other types of imprisonment devices, such as manacles or stocks, or in more modern-day works, shock collars/bracelets/electronic monitors for anyone who tries to take advantage of the wide spacing and puts as much as their hand or head through.
Serious Type: the characters and the audience are meant to take the bars seriously even though they're clearly spaced far enough apart to allow escape. In this type the bars are purely visual shorthand.  Or perhaps, simply, The Guards Must Be Crazy.
Comical Type: the character in the cell lampshades the spacing of the bars by sticking his/her head or torso through.  A particularly savvy character might even wait for the jailor to leave before slipping between the bars and making his/her escape.
When presented as a serious obstacle, this is very similar to the Insurmountable Waist-Height Fence
Examples:
- One of the plot points in the Dressrosa arc of One Piece is Doflamingo trapping the whole island (including some of the Straw Hats and marines) inside a cage built with his cutting string power. In closeup shots the net has a very fine mesh, but in distance shots the mesh is drawn wide enough that the characters could potentially fall right through. This demonstrates that it's done for the visual necessity of drawing the trap in a way that doesn't obscure the characters.
- In Slayers: Revolution, Zelgadis caught Pokota in a cage with bars so far apart, the little guy had to spread his arms in order to hold onto two bars at once. But he still couldn't get out.
- In The Flying Beaver Brothers: Birds vs. Bunnies, the titular beavers are imprisoned by rabbits in a cage with bars wide apart for them to walk sideways through, but they don't leave until they are broken out by a bird. Turns into a comical type later on when one of the beavers ends up in the cage again and simply escapes through the bars once the rabbits leave, while asking to himself why he and his brother didn't think of this before.
- Bartok the Magnificent: The cage Bartok is locked in is clearly given wide enough bars for him to slip through, yet he never does. It also appears Prince Ivan could squeeze through his cage if he tried really hard and was good at contortions.
- In The Boss Baby, the cage that Francis E. Francis places Tim and the Boss Baby in looks like both of them could just climb a little and get right out of it. It doesn't really matter because they're both dropped through a trapdoor before they can even really consider it.
- In The Little Mermaid III: Ariel's Beginning, Sebastian can clearly fit through the bars of the jail cell he and the Catfish Club Band are stuck in. It's even pointed out by one of the prisoners trying to convince him to pick the lock.
- In My Little Pony: The Movie (2017), though it's kind of hard to tell, it does appear with the cage that Tempest puts Twilight Sparkle in that she could just walk out if maybe she was good at contortions. Not that it would necessarily matter, anyway, since she was without magic while in the cage and surrounded by Tempest and the Storm King's minions.
- The Night B4 Christmas: The jail cell the music group were placed in is at least wide enough for Elvin to fit through, though he never gets himself out this way.
- Rudolph the Red-Nosed Reindeer (1998): When Rudolph and his friends are caught by Stormella, she locks them up in her ice cave with icicles as bars, that should be big enough for Rudolph and Zoey to simple walk through.
- In The Secret of NIMH 2: Timmy to the Rescue, When Timmy is locked up by Evil Martin, the bars are clearly wide enough for him to squeeze through.
- In the Catwoman (2004) movie, the title character breaks out of jail by slipping between the bars.
- In The Flintstones in Viva Rock Vegas, Fred and Barney are in a jail. While the bars are close enough together to give Fred trouble, Barney can walk through the gaps without even shrugging. He doesn't until an item falls just out of reach and he has to step through to get them. No, it wasn't the keys; Fred actually has to tell him to go back out and get the keys and let Fred out of the cell.
- In Hot Shots! Part Deux, Colonel Walters is imprisoned inside a cage. He slips through the bars, grabs a set of keys, and slips back inside the cage. He then unlocks the door and leaves normally.
- An illustration in The Bad Beginning shows Sunny in a birdcage built this way.
- A Song of Ice and Fire. As part of the propaganda spread about Tyrion Lannister after his escape from Kings Landing, he's said to have wriggled between the bars of his cell because he's a dwarf. In reality the Black Cells have very solid doors, which his brother in the Kingsguard conveniently opened for him.
- There's a variation in the Monty Python's Flying Circusnote episode "Michael Ellis", where the department store sells birdcages in which to keep pet ants. But then, we the viewer can't see the ants anyway...
- In The Muppet Christmas Carol, Rizzo and Gonzo climb over a barred gate, and then Rizzo runs back between the bars to get something he dropped.
- When Snidely is shown in prison towards the end of Dudley Do-Right's Ripsaw Falls at Universal's Islands of Adventure, the bars in front of his cell are so unevenly apart that he could easily just slip out.
- In Batman: Arkham Asylum, Batman imprisons Harley Quinn in such a cell.
- In Donkey Kong 64, all of the Kongs that aren't Donkey Kong himself have been imprisoned, but though Tiny Kong is small enough to fit through the bars, she can only escape when Diddy solves the puzzle of the room. Dazzling Addar figures that the bars are voodoo, thus also explaining why the imprisoned Kongs can only use their "one-shot voodoo" padless Bananaportation power once they retract (or the cage breaks, in Chunky's case). K. Lumsy can possibly squeeze through the bars in his massive cage, as well.
- The Legend of Zelda: The Wind Waker: The wooden cage where Ganondorf keeps his kidnapped children has this problem. The relevant cutscenes make it pretty obvious that both Link and his captive sister could easily fit between the bars. This is far from the only thing keeping them there (it's in a properly-locked room at the top of a heavily-guarded evil fortress), and the cage itself may be intended to protect the prisoners from the giant bird guarding the area; but it's still pretty silly when Link ineffectually and unnecessarily tries to force the door open.
- In The Lord of the Rings Online, the prisoners in the jail in Bree-town really should be able to just walk out of there.
- In Ratchet & Clank: Up Your Arsenal, there is a containment area on the Starship Phoenix with bars like these. The Player Character actually can walk between the bars, but the NPCs in there never think of escaping this way.
- One of the many and humorous signs Raven's Cry is a Obvious Beta is a guy stuck in a prison cell that's literally half open.
- Spyro: Year of the Dragon: In both the original and Reignited versions, the bars for each of the allies cages are clearly widely spaced enough for them to squeeze through, yet you have to pay Moneybags to let them out.
- Undertale: At one point Papyrus tries to block your progress by putting up a set of bars. Papyrus being Papyrus, the bars are so widely spaced you can simply walk through them. Sans even points this out.
- In Homestuck, Feferi's pet cuttlefish are noted to easily swim through the bars of the birdcages she keeps them in. She's fine with this, possibly because she plans on applying this "adoption" to her fellow trolls.
- Rusty and Co.: If the bars from the cells of the stadium's gaol may keep in a large, burly man like Malevolus, they look way too spread apart to hold in a pair of thin elves.
- Subverted in the climax of Spacetrawler with a group of caged Eebs. One of them realizes the bars are wide enough for them (and not Martina) to fit through, only to discover it's also reinforced with an "invisibar wire" mesh. Cue a "Boink!" as the Eeb walks right into it and a "Chuff!" as Martina catches up and stabs them.
- In Pony life with Lenora and Finola, in one episode, the two are put in jail, and Lenora accidentally walks out of their cell through the bars and then re_enters without even realizing it.
- In the episode "Give and Let Give", the cage Jason and Michelle are in has bars far apart for them to just escape if they tried.
- Zig-zagged in "Do Unto Brothers". The bars are narrow enough to prevent the penguins from escaping, but not the kids. As Michelle puts it...
Michelle: This cell was built to hold penguins, not kids.
- Adventure Time:
- In "Up a Tree", Finn spends some time in a prison such as this. At the end, he indeed just walks away.
- Exaggerated in "What Have You Done?", where Ice King is imprisoned in a cell with only two bars. He even openly criticizes Finn and Jake for it. They eventually add more bars while he stands and watches, powerless to stop them without his crown.
- Animaniacs: The city pound Rita and Runt are in during "When Rita Met Runt" has those.
- Played with in the Avatar: The Last Airbender episode "Avatar Day". Aang is clearly too small for the adult-sized stocks, so he easily slips in and out of them while talking to his fellow inmates. This is all part of the episode's premise that Aang is voluntarily submitting to justice when he is obviously powerful enough to escape any time he wanted to.
- Bounty Hamster. "Planet of the Japes" involves a Planet of Hats whose hat is practical jokes. A dissident who opposes this idea is thrown into prison for years, until he leans against the bars and discovers they're made of rubber.
- In "Max's Comic Adventure" on Dragon Tales, the gaps between the bars of Mondo Mouse's cage are clearly big enough for him to just walk through, but nevertheless, Max, Emmy and the dragons have to rescue him by figuring out a code to raise up the bars, making it a serious example.
- Duckman: Seen in "Ride the High School" when King Chicken traps Duckman, Aunt Bernice, and Cornfed in a cage. Aunt Bernice seduces him with promises of forming a band. The entire time they are imprisoned, nobody questions the bar widths, even though the antagonist actually walks between the bars for a few scenes to prod Duckman.
- In the Max Courage episode of Evil Con Carne, the kids are put in a cell resembling a medieval gate, with the gaps wide enough that the kids could crawl through them if they tried.
- In the Garfield TV special Here Comes Garfield, Garfield and Odie are taken to the pound. Odie is thrown into the back of an animal control truck where the bars are more than wide enough for him to slip through. Later, when Garfield and Odie are in the pound, all the cage bars are wide enough for even Garfield to walk out, but nobody seems to notice.
- Kung Fu Panda: Legends of Awesomeness: Viper is hung from a chain with the cuff around her neck, but it never occurs to the villains-of-the-week, or to her, that she could just slither out of it because she is a viper.
- Larry & Steve: At the pound, Steve's bars are clearly wide enough that he could squeeze through if he tried.
- Looney Tunes: Tweety's cage usually has bars wide enough apart for him to fly right through — but they're mostly there to keep Sylvester out anyway, and he does it if he has a good enough reason.
- My Little Pony: Friendship Is Magic: Seen in "Twilight's Kingdom Part 2" when Discord traps Twilight's friends and Spike in a cage◊. Even Pinkie Pie doesn't notice, putting it in the serious category.
- On one Oh Yeah!  When the cat asks how they can possibly escape, the kid simply slips through the bars. The cat, amused at how simple it is, hops back and forth between the bars ("I'm in, I'm out, I'm in, I'm out...") and ends up being hit by the ray. (Being a cartoon character, he made it.)
- The Powerpuff Girls: In many episodes, the jail bars are clearly wide enough for the villains to escape through, yet they never attempt to do so.
- The Simpsons episode "The Frying Game" has Marge and Homer in jail together, in a cell whose bars are clearly too close together for Homer but Marge could walk right through them. She doesn't, making this a Serious Type.
- Sonic the Hedgehog: As pointed out by The Nostalgia Critic, the bars of the cage Sonic and Tails are trapped in during Adventures of Sonic the Hedgehog episode "Subterranean Sonic" are easily wide enough for the two of them to escape through.
- Spongebob Squarepants: In various episodes such as "Life of Crime", the bars in Bikini Bottom jail are wide enough for the characters to escape through. In "Employee of the month", Spongebob actually escapes from a trap with these bars by sliding out sideways.
- In "Victor the Villain" on Wallykazam!, Victor traps Wally and his pet dragon Norville in a cage with bars spaced such that Norville (a small dragon) could probably at least escape from them.
- Winnie-the-Pooh: The New Adventures of Winnie the Pooh has an Imagine Spot episode that portrays the wild west and shows a jail cell that has bars wide enough to walk though and the characters actually do, but still don't think to escape this way. Of course, that's nothing compared to the fact that the jail cell didn't have a back wall.
- An especially egregious case in Xiaolin Showdown, where Dojo (prophesied to turn evil every 1,500 years or so) is locked inside a pet-carrier with just two bars. This might be enough for your average cat or dog, but Dojo has the rough dimensions of a garden hose, and at one point he cajoles Omi to slip some egg-rolls through the bars, which are exactly as thin as he is. The bars might be magically enchanted to block him from escaping, given the setting being a world where magic artifacts exists.


Anonutopia crowdfunding campaign has started
Today we started first phase in our crowdfunding campaing to fund Anonutopia and its projects.
Read More (Soon)Because blockchain's killer app is a smart contract based decentralized Internet country with its own cryptocurrencies, universal basic income, ATM network, taxi app, housing app and similar Open Source applications.
Read More Apply for CitizenshipWe have developed our own stable cryptocurrency and independent international banking system.
Read MoreAnonutopia will have its own infrastructure, apps and projects in order to make profit.
Read MoreAll profit Anonutopia makes will be used to provide universal basic income to its citizens - Anonutopians.
Read moreAnonutopia is an anonymous and decentralized Internet entity. As such, it can't provide all the services it needs to provide without any external help from individuals and companies. And because of this fact, there are numerous opportunities to earn cryptocurrencies and make profit with Anonutopia:
Become Anote holder
Run AnonOracle
Become Anonutopia Bankster
Become Anonutopia Gateway
Read more about it here.
Today we started first phase in our crowdfunding campaing to fund Anonutopia and its projects.
Read More (Soon)We have finished first MVP versions of Anonutopia wallet and cryptocurrencies - Anote and crypto fiat equivalents.
Read More (Soon)Serbian Anonymous, a hacktivist group from Serbia today announced that they are joining Anonutopia project.
Read More (Soon)
In order to claim your free Anote, join our Telegram group and ask our friendly bot for it.
Click the button bellow to find out more!
By purchasing Anote you're in fact crowdfunding a pure direct democracy project - Anonutopia. We will use this money to:
Attract more citizens
Build ATM network
Bootstrap commercial projects
Help Balkan countries test-drive direct democracy
Read more about our crowdfunding campaign here.


The Extreme Ultraviolet Spectrometer (EUVS) was used to observe the variations in
the solar EUV flux in the wavelength range from 140 to 1850 A and the atmospheric attenuation
at various fixed wavelengths. This provided quantitative atmospheric structure and composition
data. The instrument consisted of 24 grazing-incidence grating monochromators, using parallel-slit
systems for entrance collimation and photoelectric detectors at the exit slits. Twelve of these
monochromators had wavelength scan capability, each with 128 selectable wavelength positions,
which could also automatically step scan through these positions. The other 12 monochromators
operated at fixed wavelengths with fields of view smaller than the full solar disk to aid in the
atmospheric absorption analysis. The spectral resolution varied from 2 to 54 A depending upon
the particular instrument. The field of view varied from 60 x 60 down to 3 x 6 arc min. All 24
monochromator-entrance axes were co-aligned parallel. A solar pointing system could point to 256
different positions, execute a 16-step one-dimensional scan or a full 256-step raster. The time
resolution varied from 0.5 s for observing 12 fixed wavelengths up to 256 s for programming the
EUVS through all possible modes. More details can be found in H. E. Hinteregger et al.,
Radio Sci., v. 8, n. 4, p. 349, 1973.
Version:2.2.1
The Extreme Ultraviolet Spectrometer (EUVS) was used to observe the variations in
the solar EUV flux in the wavelength range from 140 to 1850 A and the atmospheric attenuation
at various fixed wavelengths. This provided quantitative atmospheric structure and composition
data. The instrument consisted of 24 grazing-incidence grating monochromators, using parallel-slit
systems for entrance collimation and photoelectric detectors at the exit slits. Twelve of these
monochromators had wavelength scan capability, each with 128 selectable wavelength positions,
which could also automatically step scan through these positions. The other 12 monochromators
operated at fixed wavelengths with fields of view smaller than the full solar disk to aid in the
atmospheric absorption analysis. The spectral resolution varied from 2 to 54 A depending upon
the particular instrument. The field of view varied from 60 x 60 down to 3 x 6 arc min. All 24
monochromator-entrance axes were co-aligned parallel. A solar pointing system could point to 256
different positions, execute a 16-step one-dimensional scan or a full 256-step raster. The time
resolution varied from 0.5 s for observing 12 fixed wavelengths up to 256 s for programming the
EUVS through all possible modes. More details can be found in H. E. Hinteregger et al.,
Radio Sci., v. 8, n. 4, p. 349, 1973.
| Role | Person | |
|---|---|---|
| 1. | PrincipalInvestigator | spase://SMWG/Person/Hans.E.Hinteregger |
Information about AE-E EUVS
Detailed information about the Extreme Ultraviolet Spectrometer (EUVS) on the AE-E mission.


| AVR Libc Home Page | AVR Libc Development Pages | ||||
| Main Page | User Manual | Library Reference | FAQ | Alphabetical Index | Example Projects |
#include <avr/sleep.h>
Use of the SLEEP
instruction can allow an application to reduce its power comsumption considerably. AVR devices can be put into different sleep modes. Refer to the datasheet for the details relating to the device you are using.
There are several macros provided in this header file to actually put the device into sleep mode. The simplest way is to optionally set the desired sleep mode using set_sleep_mode()
(it usually defaults to idle mode where the CPU is put on sleep but all peripheral clocks are still running), and then call sleep_mode()
. This macro automatically sets the sleep enable bit, goes to sleep, and clears the sleep enable bit.
Example:
#include <avr/sleep.h>
...
set_sleep_mode(<mode>);
sleep_mode();
Note that unless your purpose is to completely lock the CPU (until a hardware reset), interrupts need to be enabled before going to sleep.
As the sleep_mode()
macro might cause race conditions in some situations, the individual steps of manipulating the sleep enable (SE) bit, and actually issuing the SLEEP
instruction, are provided in the macros sleep_enable()
, sleep_disable()
, and sleep_cpu()
. This also allows for test-and-sleep scenarios that take care of not missing the interrupt that will awake the device from sleep.
Example:
#include <avr/interrupt.h> #include <avr/sleep.h> ... set_sleep_mode(<mode>); cli(); if (some_condition) { sleep_enable(); sei(); sleep_cpu(); sleep_disable(); } sei();
This sequence ensures an atomic test of some_condition
with interrupts being disabled. If the condition is met, sleep mode will be prepared, and the SLEEP
instruction will be scheduled immediately after an SEI
instruction. As the intruction right after the SEI
is guaranteed to be executed before an interrupt could trigger, it is sure the device will really be put to sleep.
Functions | |
| void | sleep_enable (void) |
| void | sleep_disable (void) |
| void | sleep_cpu (void) |
| void sleep_cpu | ( | void | ) |
Put the device into sleep mode. The SE bit must be set beforehand, and it is recommended to clear it afterwards.
| void sleep_disable | ( | void | ) |
Clear the SE (sleep enable) bit.
| void sleep_enable | ( | void | ) |
Put the device in sleep mode. How the device is brought out of sleep mode depends on the specific mode selected with the set_sleep_mode() function. See the data sheet for your device for more details.
Set the SE (sleep enable) bit.


i
Reporter
Username
Password
Sign In
Forgot Password
or
Create account
Fill the form below to create an account
Register
or
Sign In
Let’s build the Nation
together
iReporter
is a platform for every citizens


This is yet another fork of jashkenas's Ember/Backbone benchmark, via this fork Animate with Backbone Animate with Backbone (fast) Animate with Ember+HTMLBars Animate with React Animate with Ractive Animate with Basis.js Animate with Basis.js (template) Animate with nothing Animate with altr


]{% extends 'base.html' %} {% load social %} {% block title %} | Sign up with email address{% endblock %} {% block main %} {% get_social_apps as social_apps %}
Please sign up to continue.
Already signed up? Please sign in using an email address{% if social_apps %}, or use your social account{% endif %}.


GC(1) GC(1) NAME gvgen - generate graphs SYNOPSIS gvgen [ -d? ] [ -cn ] [ -Cx,y ] [ -g[f]x,y ] [ -G[f]x,y ] [ -hn ] [ -kn ] [ -bx,y ] [ -pn ] [ -sn ] [ -Sn ] [ -tn ] [ -Tx,y ] [ -wn ] [ -ooutfile ] DESCRIPTION gvgen generates a variety of simple, regularly-structured abstract graphs. OPTIONS The following options are supported: -c n Generate a cycle with n vertices and edges. -C x,y Generate an x by y cylinder. This will have x*y vertices and 2*x*y - y edges. -g [f]x,y Generate an x by y grid. If f is given, the grid is folded, with an edge attaching each pair of opposing corner vertices. This will have x*y vertices and 2*x*y - y - x edges if unfolded and 2*x*y - y - x + 2 edges if folded. -G [f]x,y Generate an x by y partial grid. If f is given, the grid is folded, with an edge attaching each pair of opposing corner ver‐ tices. This will have x*y vertices. -h n Generate a hypercube of degree n. This will have 2^n vertices and n*2^(n-1) edges. -k n Generate a complete graph on n vertices with n*(n-1)/2 edges. -b x,y Generate a complete x by y bipartite graph. This will have x+y vertices and x*y edges. -p n Generate a path on n vertices. This will have n-1 edges. -s n Generate a star on n vertices. This will have n-1 edges. -S n Generate a Sierpinski graph of order n. This will have 3*(3^(n-1) - 1)/2 vertices and 3^n edges. -t n Generate a binary tree of height n. This will have 2^n-1 vertices and 2^n-2 edges. -T x,y Generate an x by y torus. This will have x*y vertices and 2*x*y edges. -w n Generate a path on n vertices. This will have n-1 edges. -o outfile If specified, the generated graph is written into the file out‐ file. Otherwise, the graph is written to standard out. -d Make the generated graph directed. -? Print usage information. EXIT STATUS gvgen exits with 0 on successful completion, and exits with 1 if given an ill-formed or incorrect flag, or if the specified output file could not be opened. AUTHOR Emden R. Gansner<EMAIL_ADDRESS>SEE ALSO gc(1), acyclic(1), gvpr(1), gvcolor(1), ccomps(1), sccmap(1), tred(1), libgraph(3) 27 March 2008 GC(1)


|
Earthquakemodels
Here is the official documentation for generating Earthquake Risk Models using Genetic Algorithms.
|
Functions | |
| def | execGamblingScore (year) |
| def | execAss (year) |
| def | execLTest (year) |
| def | execNTest (year) |
| def | execLogLikelihood (year) |
| def | execTestsbyYear (start=2000, end=2011) |
| def applyTests.execAss | ( | year | ) |
Calculates the ASS Test of the Models: GAModel, RandomModel
Definition at line 29 of file applyTests.py.
| def applyTests.execGamblingScore | ( | year | ) |
Calculates the Gambling Score of the Models: GAModel, RandomModel
Definition at line 9 of file applyTests.py.
| def applyTests.execLogLikelihood | ( | year | ) |
Shows the loglikelihood of the Models: GAModel, RandomModel
Definition at line 86 of file applyTests.py.
| def applyTests.execLTest | ( | year | ) |
Calculates the LTest of the Models: GAModel, RandomModel
Definition at line 48 of file applyTests.py.
| def applyTests.execNTest | ( | year | ) |
Calculates the NTest of the Models: GAModel, RandomModel
Definition at line 67 of file applyTests.py.
| def applyTests.execTestsbyYear | ( | start = 2000 , |
|
end = 2011 |
|||
| ) |


1 Formerly, in all their sacrifices, the Pelasgians called upon gods without giving name or appellation to any (I know this, because I was told at Dodona); for as yet they had not heard of such. They called them gods from the fact that, besides setting everything in order, they maintained all the dispositions.
2 Then, after a long while, first they learned the names of the rest of the gods, which came to them from Egypt, and, much later, the name of Dionysus; and presently they asked the oracle at Dodona about the names; for this place of divination, held to be the most ancient in Hellas, was at that time the only one.
3 When the Pelasgians, then, asked at Dodona whether they should adopt the names that had come from foreign parts, the oracle told them to use the names. From that time onwards they used the names of the gods in their sacrifices; and the Greeks received these later from the Pelasgians.


| | |
- CalculateIntensityFromPolarizationAnalyser(process, B, sitevec, sglist, lam, hkl, hkln, psideg, pol_eta_deg, pol_th_deg=45, stokesvec_swl=[0, 0, 1], K=None, Time=None, Parity=None, mk=None, lk=None, sk=None)
- process = 'Scalar', 'E1E1', 'E1E2', 'E2E2', 'E1E1mag', 'NonResMag'
Calculate intensity from polarization analyser vs pol_eta (analyser rotation)
pol_eta_deg can be a scalar or array/list
pol_th_deg is polarizer theta angle (deg) (default 45)
stokesvec_swl is Stokes as per SWL papers (P3 = horizontal linear, default [0 ,0, 1])
- CalculateIntensityInPolarizationChannels(process, B, sitevec, sglist, lam, hkl, hkln, psideg, K=None, Time=None, Parity=None, mk=None, lk=None, sk=None)
- process = 'Scalar', 'E1E1', 'E1E2', 'E2E2', 'E1E1mag', 'NonResMag'
Calculate intensity in four linear polarization channels
psi can be a scalar or array/list
- ClebschGordan(j1, j2, m1, m2, J, M, warn=True)
- ClebschGordan(j1, j2, m1, m2, J, M, cglimit=20,warn=True)
Computes exact sympy form for Clebsch-Gordan coefficient
<j1 j2; m1 m2|j1 j2; JM>.
For reference see
http://en.wikipedia.org/wiki/Table_of_Clebsch-Gordan_coefficients.
Clebsch Gordan numpy function by Michael V. DePalatis, modified and converted to sympy by SPC
warn gives warning for unphysical coefficients
Adapted from sympy ClebschGordan
- E1E1ResonantMagneticScatteringMatrix(mk, esig_c, e0pi_c, e1pi_c, q0_c, q1_c)
- Calculate 2x2 scattering amplitude matrix for E1E1 resonant magnetic scattering
- NonResonantMagneticScatteringMatrix(sk, lk, esig_c, e0pi_c, e1pi_c, q0_c, q1_c)
- Calculate 2x2 scattering amplitude matrix for non-resonant magnetic scattering
spin and orbital components (Complex) for reflection are sk, lk
BB and AA are B (spin) and A (orbit) coupling vectors from SWL, Blume etc
- StoneCoefficients(CouplingSequenceList, k=(-0-1j))
- StoneCoefficients(CouplingSequenceList,k=phase_convention)
Sympy Spherical-Cartesian conversion coefficients from
A.J. Stone Molecular Physics 29 1461 (1975) (Equation 1.9)
CouplingSequenceList is the coupling sequence for spherical tensors,
each time coupling to a new vector to form a tensor of given rank
(sequence always starts with 1)
k=-I for Condon & Shortley phase convention (default) of k=1 for Racah
e.g. StoneCoefficients([1,2,3]) returns conversion coefficients for K=3, coupling with
maximum rank and Condon & Shortley (default) phase convention
Example: C123=StoneCoefficients([1,2,3]) returns conversion matrix for coupling sequence 123 (K=3)
print(lcontract(C123,3,[1,0,0,0,0,0,0])) returns table values for Q=-3
Numpy version converted from, Sympy version
- StoneCoupleVector(Cold, Knew, C1)
- StoneCoupleVector(Cold,Knew,C1)
couple Stone coefficients Cold to a new vector to make coefficient for spherocal tensor of rank Knew
using vector coupling coefficients C1
A.J. Stone Molecular Physics 29 1461 (1975) (Equation 1.9)
Numpy version converted from Sympy version
- StoneSphericalToCartConversionCoefs(K, Calc=True, k=(-0-1j))
- Condon&Shortley phase convention (k=-i in Stone's paper)
from FortranForm (No - CForm?) First List->array, del other lists,spaces, extra bracket around first level
If Calc==False then use these expressions from Mathematica, else calculate them numerically
- TensorScatteringMatrix(mpol, Fs, time, parity, esig_c, e0pi_c, e1pi_c, q0_c, q1_c)
- Calculate 2x2 scattering amplitude matrix for tensor scattering
- apply_sym(Tensor, symop_list, Bmat=array([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]]), P=None, T=1)
- apply point sym ops in symop_list to tensor of rank K
Optional Bmat is used to transform arrays to Cartesian from crystal basis
Default time (T) sym +1; no default for parity (P)
- calc_sf(Tensor, R, hkl, spacegroup_list, Bmat=array([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]]), P=None, T=1)
- calc structure factor tensor for symop_list to tensot T of rank K at position R hkl=Q
Optional Bmat is used to transform arrays to Cartesian from crystal basis
- calculatescatteringmatrix(process, B, lam, psival, hkl, hkln, Fs, Time=None, Parity=None, mk=None, sk=None, lk=None)
- Calculate G for specified scattering process; require B, lam, psival, hkl, hkln
process = 'Scalar', 'E1E1', 'E1E2', 'E2E2', 'E1E1mag', 'NonResMag'
Fs (structure factor spherical tensor), Time & Parity symmetry, mk, sk, lk are required for specific processes only
2 x 2 G matrix defined in SWL papers
- calcxrayvectors(B, lam, psi, hkl, hkln)
- calculate relevant Cartesian vector in sample reference frame
return(h, q0, q1, esig, e0pi, e1pi)
- caltheta(B, lam, hkl)
- Calculate Bragg angle theta
:param B: B matrix
:param lam: wavelength in A
:param hkl: [hkl]
:return: float: angle in deg
- cart_to_spherical_tensor(Tc)
- crystal_point_sym(spacegroup_list)
- crystal_to_cart_operator(S, B)
- equiv_sites(spacegroup_list, sitevec)
- equiv_sites(spacegroup_list, sitevec)
returns symmetry-equivalent sites for selected site
- firstCell(V)
- genpos2matvec(gen_pos_string)
- convert general position string to vector/matrix form (floats) using lists as row vectors
- indexlist(shape)
- indexlist(shape)
create a list of index lists covering all indices for shape list (all possible indices)
(Numpy 1.6 has new indexing functionality that my render this obsolete)
- isGroup(G)
- Tests if G is a group
:param G: is a list of [mat, vec, timescalar]
:return: Boolean
- latt2b(lat, direct=False, BLstyle=False)
- follow Busing&Levy, D.E.Sands
direct=False: normal recip space B matrix (B&L)
direct=True, BLstyle=True: Busing & Levy style applied to real space (i.e. x||a)
direct=True, BLstyle=False: Real space B matrix compatible with recip space B matrix
- msg(num, txt=['plus', 'minus', 'zero', 'other'])
- return message text for +1,-1, 0, other (e.g. None)
- norm_array(Array, Minval=0.001)
- Normalise array by largest abs value if >Minval (avoids trying to renormalise zero array)
- print_tensors(B, sitevec, sglist, hkl=array([0, 0, 0]), K=None, Parity=1, Time=1)
- return str of tensors
- rand(...) method of numpy.random.mtrand.RandomState instance
- rand(d0, d1, ..., dn)
Random values in a given shape.
.. note::
This is a convenience function for users porting code from Matlab,
and wraps `random_sample`. That function takes a
tuple to specify the size of the output, which is consistent with
other NumPy functions like `numpy.zeros` and `numpy.ones`.
Create an array of the given shape and populate it with
random samples from a uniform distribution
over ``[0, 1)``.
Parameters
----------
d0, d1, ..., dn : int, optional
The dimensions of the returned array, must be non-negative.
If no argument is given a single Python float is returned.
Returns
-------
out : ndarray, shape ``(d0, d1, ..., dn)``
Random values.
See Also
--------
random
Examples
--------
>>> np.random.rand(3,2)
array([[ 0.14022471, 0.96360618], #random
[ 0.37601032, 0.25528411], #random
[ 0.49313049, 0.94909878]]) #random
- scalar_contract(X, T)
- sf_symmetry(R, hkl, spacegroup_list)
- analyse symmetry of any possible structure factor (mainly for information)
returns [sym_phases, gen_scalar_allowed, site_scalar_allowed, tensor_allowed, Psym, Tsym, PTsym]
- site_sym(spacegroup_list, sitevec)
- spacegroup_list_from_genpos_list(genposlist)
- spherical_to_cart_tensor(Ts)
- symmetry_str(R, hkl, spacegroup_list)
- analyse symmetry of any possible structure factor (mainly for information)
returns str
- tensorcalc(B, sitevec, sglist, hkl=array([0, 0, 0]), K=None, Parity=1, Time=1)
- calculate scatterin tensor
B = B matrix
sitevec = [u,v,w]
sglist = list of symmetries
hkl, hkln: hkl values for reflection and azimuthal reference
K = tensor rank
Parity = +/- 1
Time = +/- 1
returns: Ts, Tc1, Tc_atom, Tc_crystal, Ts_atom, Ts_crystal, Fc, Fs
Ts Calcualted spherical tensor
Tc1 Calculated cartesian tensor
Tc_atom Atomic cartesian tensor
Tc_crystal Crystal cartesian tensor
Ts_atom Atomic spherical tensor
Ts_crystal Crystal spherical tensor
Fc SF Crystal tensor
Fs SF spherical tensor
- tensorproperties(sitevec, sglist, hkl=array([0, 0, 0]), Parity=1, Time=1)
- Return tensor properties
sitevec = [u,v,w]
sglist = list of symmetries
hkl, hkln: hkl values for reflection and azimuthal reference
returns: Ts, Tc1, Tc_atom, Tc_crystal, Ts_atom, Ts_crystal, Fc, Fs
Ts Calcualted spherical tensor
Tc1 Calculated cartesian tensor
Tc_atom Atomic cartesian tensor
Tc_crystal Crystal cartesian tensor
Ts_atom Atomic spherical tensor
Ts_crystal Crystal spherical tensor
Fc SF Crystal tensor
Fs SF spherical tensor
- theta_to_cartesian(hkl, hkln, psi, B)
- Unitary matrix for transformation from theta to cartesian coordinate system
- transform_cart(T, S, P=0)
- #transform Cart tensor rank K using symmetry operator S
#If optional parameter P (parity) is given then a correction is made to account for the otherwise incorrect
#tranformation of Cartesian tensors derived from spherical pseudotensors (see Mittelwihr paper)
- xtensor(process, rank, time, parity, e0, e1, q0, q1)
- Calculates resonant scattering tensor as per Lovesey
This version is a dump of the output of a Mathematica implementation (hence messy!)
The Sympy version of this calculation carries out the same tensor calculation
|


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use Table | |
|---|---|
| obvious.data | Package obvious.data This package contains the standard interfaces for the Obvious data model. |
| obvious.data.event | Package obvious.data.event This package contains listener used for event management. |
| obvious.data.util | Package obvious.data.util This package contains util interfaces for data model such as Iterator and Operator. |
| obvious.impl | Package obvious.data This packages gives some simple implementation following obvious interfaces. |
| obvious.util | Package obvious.util TODO document the package. |
| obvious.viz | Package obvious.viz TODO document the package. |
| Uses of Table in obvious.data |
|---|
| Subinterfaces of Table in obvious.data | |
|---|---|
interface |
Schema
Schema is an interface describing the columns of a Tuple and by extension of a Table. |
| Methods in obvious.data that return Table | |
|---|---|
abstract Table |
DataFactory.createTable(Schema schema)
Creates a table from an existing Schema instance. |
abstract Table |
DataFactory.createTable(Schema schema,
java.util.Map<java.lang.String,java.lang.Object> param)
Creates a table from an existing Schema instance. |
Table |
Network.getEdgeTable()
Gets an obvious Table containing the edges of this Network instance. |
Table |
Network.getNodeTable()
Gets an obvious Table containing the nodes of this Network instance. |
Table |
Tuple.getTable()
Returns the Table instance that backs this Tuple, if it exists. |
abstract Table |
DataFactory.wrapTable(java.lang.Object underlyingTable)
Creates a table from an existing table object. |
| Uses of Table in obvious.data.event |
|---|
| Methods in obvious.data.event with parameters of type Table | |
|---|---|
void |
TableListener.tableChanged(Table t,
int start,
int end,
int col,
int type)
Notification that a table has changed. |
| Uses of Table in obvious.data.util |
|---|
| Methods in obvious.data.util that return Table | |
|---|---|
Table |
Transform.transform(Table t)
Operates transformation on a table. |
| Methods in obvious.data.util with parameters of type Table | |
|---|---|
boolean |
Predicate.apply(Table table,
int rowId)
Applies a predicate on a table's row. |
Table |
Transform.transform(Table t)
Operates transformation on a table. |
| Uses of Table in obvious.impl |
|---|
| Classes in obvious.impl that implement Table | |
|---|---|
class |
SchemaImpl
This is a basic Schema implementation. |
class |
TableImpl
Example implementation of Interface Table. |
| Methods in obvious.impl that return Table | |
|---|---|
Table |
DataFactoryImpl.createTable(Schema schema)
|
Table |
DataFactoryImpl.createTable(Schema schema,
java.util.Map<java.lang.String,java.lang.Object> param)
Returns an Obvious Table. |
Table |
TupleImpl.getTable()
Returns the Table instance that backs this Tuple, if it exists. |
Table |
DataFactoryImpl.wrapTable(java.lang.Object underlyingTable)
Returns a Network instance if the underlyingTable is an instance of an implementation of Table. |
| Methods in obvious.impl with parameters of type Table | |
|---|---|
protected void |
ObviousLinkListener.delete(Table table,
int start,
int end,
int col)
Deletes row in the table associated to the source Table. |
protected void |
ObviousLinkListener.insert(Table table,
int start,
int end,
int col)
Inserts row in the table associated to the source Table. |
void |
ObviousLinkListener.tableChanged(Table t,
int start,
int end,
int col,
int type)
Notifies that a table has changed. |
protected void |
ObviousLinkListener.update(Table table,
int start,
int end,
int col)
Updates row in the table associated to the source Table. |
| Constructors in obvious.impl with parameters of type Table | |
|---|---|
EdgeImpl(Table tableIn,
int rowId)
Constructor for Node. |
|
FilterIntIterator(Table t,
Predicate inPred)
Constructor. |
|
NodeImpl(Table tableIn,
int rowId)
Constructor for Node. |
|
ObviousLinkListener(Table targetTable)
Constructor. |
|
TupleImpl(Table tableIn,
int rowId)
Constructor from a table. |
| Uses of Table in obvious.util |
|---|
| Methods in obvious.util with parameters of type Table | |
|---|---|
static void |
ObviousLib.fillTable(Table sourceTable,
Table filledTable)
Fills an obvious table with the content of an another table. |
| Uses of Table in obvious.viz |
|---|
| Methods in obvious.viz that return Table | |
|---|---|
protected Table |
Visualization.applyPredToTable(Table inData)
Apply the predicate to the table. |
| Methods in obvious.viz with parameters of type Table | |
|---|---|
protected Table |
Visualization.applyPredToTable(Table inData)
Apply the predicate to the table. |
abstract Visualization |
VisualizationFactory.createVisualization(Table table,
Predicate pred,
java.lang.String visName,
java.util.Map<java.lang.String,java.lang.Object> param)
Creates an instance of Visualization. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


Feel free to contact us via an email or by phone. We answear phone calls between 9:00 am and 7:00 pm (CEST). We usually respond to eamil in a day time.


Four men arrested in connection with investigation into serious incident in Kildare
On Saturday, gardaí were called out to a serious public order incident after 2pm in Athy.
by Orla DwyerFOUR MEN HAVE been arrested by gardaí in connection with an investigation into an incident of serious assault and criminal damage at a halting site in Athy, Co Kildare.
On Saturday, gardaí were called out to a serious public order incident after 2pm. They discovered a man in his 50s with apparent lacerations to his head and body at the scene.
He was treated and taken to Portlaoise Hospital. The man’s injuries are not thought to be life-threatening and he has since been moved to Beaumont Hospital for further treatment.
Four men aged in their 20s and 30s were arrested earlier today in Athy in connection with the investigation. They are currently detained at Garda Stations in Kildare.
Significant damage was caused to a 4×4 vehicle belonging to the injured man at the scene of the incident.
The driver’s window and rear window were smashed. The vehicle was removed for forensic and technical investigation by gardaí. A second vehicle found close to the scene was also taken.
Gardaí are appealing for anyone who can assist in the investigation to contact the incident room at Athy Garda Station<PHONE_NUMBER> or the Garda Confidential Line 1800 666 111.
The investigation is ongoing.
Comments are closed because of the ongoing investigation.


Before Change
// KeyboardInterruptCheck to finish first (the corresponding wait should
// trigger the failure), so as to make the framework kill the remaining
// three.
checks = [
KeyboardInterruptCheck(system=self.system,
resources=self.resources),
SleepCheck(10, system=self.system, resources=self.resources),
SleepCheck(10, system=self.system, resources=self.resources),
SleepCheck(10, system=self.system, resources=self.resources)
]
self._run_checks(checks, 2)
def test_kbd_interrupt_in_setup_with_concurrency(self):
checks = [
After Change
// KeyboardInterruptCheck to finish first (the corresponding wait should
// trigger the failure), so as to make the framework kill the remaining
// three.
checks = [KeyboardInterruptCheck(),
SleepCheck(10), SleepCheck(10), SleepCheck(10)]
self._run_checks(checks, 2)
def test_kbd_interrupt_in_setup_with_concurrency(self):
checks = [SleepCheck(1), SleepCheck(1), SleepCheck(1),


Yusuf Qedan's Portfolio Page
Hi my name is Yusuf Qedan I was born and raised here in Portland. I am an aspiring full stack developer who is currently seeking employment. I have a very solid foundation when it comes to programming fundamentals and have real world experience in the high-tech industry. I became interested in computer software and hardware when I got involved in my high school robotics team where we had to design, build and program a robot in six weeks. I decided to major in computer engineering and earned a bachelor's degree from Portland State and later worked in semiconductor manufacturing. On the job, I was reminded of my interest in software and decided to pursue opportunities where I could leverage my existing skills from college. Last year I attended Epicodus to boost my software development skills. I have since finished my education there and I am now seeking new exciting opportunities in web and Android development.
This is an Android application whose purpose is to help aspiring developers and current professionals prepare for job interviews. The app uses flashcards and multiple choice questions to help the user study. Also included is a to-do list because no application would quite be complete without one!
Download the alpha from the google play store here.
Technologies Used: Android Firebase
The game of simon implemented in JavaScript for all to enjoy. The purpose of this tiny app was to learn how to build modern JavaScript applications using asset pipelines and to have some fun making a game of course!
Play it here.
Technologeies used: HTML CSS JavaScript Node.js Gulp
| • HTML5 | • CSS3 | • SASS | • JavaScript (ES6) | • jQuery |
| • Node.js | • Angular 2 | • Ember.js | • Bootstrap | • Android |
| • Spark | • PostgreSQL | • Firebase |
| • Microprocessors | • Computer Architecture | • Robotics |
| • Operating Systems | • Data Structures |


How to Make Baklava
by wikiHow Staff ✅If you're tired of buying tiny pieces of expensive baklava, make a pan of it at home. Create a flavorful syrup with your favorite spices and use your choice of nuts to make a rich filling. Then layer sheets of buttered phyllo dough and scatter the filling in the middle. Bake your baklava until it's golden brown and pour the syrup over the hot pastry. Enjoy bites of the baklava whenever you like!
Explore this Article
Article Summary
■ Making the Syrup and Filling
■ Assembling the Baklava
■ Baking the Baklava
Related Articles
Article Summary
To make baklava, start by heating sugar, honey, water, lemon juice, and corn syrup in a saucepan over low heat for 5 minutes. Then, let the syrup mixture simmer for 5 minutes. While that's simmering, combine chopped nuts, sugar, and cinnamon to make the filling. Next, brush 7 sheets of phyllo dough with melted butter and stack them in a greased pan. Once you've done that, spread half of the filling over the dough sheets, lay down 8 more sheets, and spread the rest of the filling on top. Finally, cut the baklava into small squares or diamonds and bake it for 35 minutes at 350 degrees Fahrenheit, turning the temperature down to 300 degrees after the first 20 minutes. To learn how to serve baklava, scroll down!
Ingredients
Syrup
- 2 cups (400 g) of granulated sugar
- 1 cup (340 g) of honey
- 1 1⁄2 cups (350 ml) of water
- 2 tablespoons (30 ml) of lemon juice
- 2 tablespoons (30 ml) of light corn syrup (optional)
- 2 cinnamon sticks (optional)
- 4 to 6 whole cloves or 1/2 teaspoon (1 g) of ground cardamom (optional)
Filling
- 1 pound (450 g) of blanched almonds, pistachios, walnuts, or any combination
- 1/4 cup (50 g) of granulated sugar
- 1 to 2 teaspoons (2 to 4 g) of ground cinnamon
- 1/4 teaspoon (0.5 g) of ground cloves or cardamom (optional)
- 1 pound (450 g) of phyllo dough, thawed
- 1 cup (226 g) of butter or vegetable oil
Makes 3 dozen small pieces
Part 1 - Making the Syrup and Filling
1. Put the sugar, honey, water, and lemon juice in a saucepan. Pour 2 cups (400 g) of granulated sugar, 1 cup (340 g) of honey, 1 1⁄2 cups (350 ml) of water, and 2 tablespoons (30 ml) of lemon juice into a medium saucepan on the stove.[1]
- If you don't want to use honey, substitute the same amount of granulated sugar.
2. Add corn syrup and spices if desired. To prevent the syrup from crystallizing, you can add 2 tablespoons (30 ml) of light corn syrup. If you'd like the syrup to have a slightly spiced flavor, add 2 sticks of cinnamon that are about 3 inches (7.6 cm) in length. You can also add 4 to 6 whole cloves or 1/2 teaspoon (1 g) of ground cardamom.[2]
- For a citrus syrup, add the zest of a lemon along with 1 teaspoon (4.9 ml) of vanilla.
3. Heat the mixture over low for 5 minutes. Stir the mixture as it cooks so the sugar dissolves. Keep stirring the syrup as it heats so it cooks evenly and becomes a light syrup.[3]
- Use a wooden spoon to stir the syrup since the heat of the pot would transfer to a metal spoon.
4. Simmer the syrup for 5 minutes and remove the whole spices, if using. Once the sugar has dissolved, turn the burner to medium. Stop stirring and let the syrup cook until it thickens a little. Turn off the burner and carefully remove the cinnamon sticks and whole cloves if you used them.[4]
- Let the syrup cool while you prepare the filling.
Tip: To determine if the syrup has cooked long enough, insert a candy thermometer. It should reach 225 °F (107 °C) once it's cooked enough.
5. Chop or pulse the nuts in a food processor. Get out 1 pound (450 g) of the nuts you want to use in the baklava. If you'd like chunkier baklava, use a chef's knife to finely chop the nuts. If you want delicately textured baklava, put the nuts in a food processor and pulse them until they're coarsely ground.[5]
Tip: Although almonds or pistachios are traditional, you can use any combination of walnuts or hazelnuts as well.
6. Combine the nuts with the sugar, cinnamon, and spice, if using. Put the chopped or ground nuts into a bowl and add 1/4 cup (50 g) of granulated sugar and 1 to 2 teaspoons (2 to 4 g) of ground cinnamon. If you'd like spicier baklava, add 1/4 teaspoon (0.5 g) of ground cloves or cardamom. Stir until the nuts are combined with the sugar and spice.[6]
- For an unusual flavor combination stir in 1 teaspoon (3 g) of coffee powder.
- To give the baklava filling a bold flavor, add 1 teaspoon (2 g) of ground ginger.
Part 2 - Assembling the Baklava
1. Preheat the oven to 350 °F (177 °C) and grease a baking pan. If you'd like thicker baklava, butter the inside of a 9 in × 13 in (23 cm × 33 cm) or 9 in × 12 in (23 cm × 30 cm) pan. If you want to make thin baklava, grease a 10 in × 15 in (25 cm × 38 cm) jelly roll pan.[7]
Did You Know? If you use a pan that's light-colored, the baklava won't overbrown near the edges.
2. Melt 1 cup (226 g) of butter. Put the butter in a microwave-safe dish and microwave it for 20-second intervals until it melts. If you'd rather melt it on the stove, put the butter in a small saucepan and turn the burner to low.[8]
- If you want lower-calorie baklava, replace half of the butter with vegetable oil.
3. Brush 7 sheets of phyllo with butter and stack them in the greased pan. Open the thawed package of phyllo dough and unwrap a sheet. Spread the sheet out and lay it in the pan. Then dip a pastry brush in the melted butter and brush the phyllo sheet lightly. Lay another sheet of phyllo in the pan and brush it. Keep doing this until you've stacked 7 layers of phyllo.[9]
- If you're using a jelly roll pan, you may need to cut a few sheets of phyllo dough to size so they cover the bottom of the pan.
4. Spread 1/2 of the spiced nut filling over the phyllo. Get out the ground or chopped nut mixture with the spices and scatter 1/2 of it over the phyllo sheets in the pan. Spread them evenly so the baklava has level layers.[10]
5. Brush 8 sheets of phyllo with butter and lay them in the pan. Since this is the middle layer of baklava, it's fine to use up any torn or ripped sheets of phyllo. Try to brush butter between each of the 8 sheets as you stack them.[11]
6. Spread the remaining filling and 8 more sheets of phyllo in the pan. Scatter the other 1/2 of the spiced nut mixture evenly across the middle layer of phyllo. Then butter and layer 8 more sheets of phyllo to make the top of the baklava.[12]
7. Trim the edges and cut the baklava into small diamonds. Take a sharp knife and cut off any phyllo that's hanging over the side of the pan. Then cut 6 long strips that are 1 3⁄4 inches (4.4 cm) wide through just the top layer of phyllo. Turn the pan so you can cut long diagonal slices across the top layer of pastry. This will create small diamonds that are about 1 1⁄2 inches (3.8 cm) wide.[13]
- If you prefer, cut the baklava into small squares instead.
- If you're having trouble cutting cleanly through the phyllo, try using a serrated knife.
Part 3 - Baking the Baklava
1. Sprinkle the top of the baklava with water and bake it for 20 minutes. Dip your clean fingers in a bowl of ice water and sprinkle a little over over the top of the baklava. Then put the pan in the 350 °F (177 °C) oven and bake the baklava for 20 minutes.[14]
- The ice water will prevent the top layer of phyllo from curling as it bakes.
2. Turn the oven to 300 °F (149 °C) and bake the baklava for 15 minutes. Keep the baklava in the oven and turn the temperature down. Then bake the baklava until it becomes golden brown on the top.[15]
3. Remove the baklava and cut through the lines. Turn off the oven and carefully take the baklava out of the oven. Immediately use a sharp knife to cut through the lines you cut earlier. Cut down to the bottom of the pan.[16]
4. Pour the syrup over the hot baklava. Slowly pour the syrup or use a ladle to spoon the syrup evenly over the baklava. The phyllo will soak up the syrup as it runs down through the pieces you cut.[17]
Tip: If you made the syrup in advance and refrigerated it, warm it slightly so the phyllo absorbs it easier.
5. Cool the baklava for at least 4 hours before serving. Leave the baklava to sit at room temperature while it cools and absorbs the syrup. Then you can serve it or cover and store it for up to 1 week.[18]
- If the baklava looks dry, drizzle a little more syrup over it before serving.
- The flavor and texture of baklava will actually be at its best 1 day after you pour the syrup over it.
Tips
- To thaw frozen phyllo dough, leave it in the package on the counter for 5 hours or put the package in the refrigerator the night before you want to use it.[19]
- To prevent the unused phyllo from drying out while you assemble the baklava, cover it with a damp dishcloth.
Things You'll Need
- Measuring cups and spoons
- Medium saucepan
- Spoons
- Microwave-safe bowl or small saucepan
- Pastry brush
- Knife
- 9 in × 13 in (23 cm × 33 cm), 9 in × 12 in (23 cm × 30 cm), or 10 in × 15 in (25 cm × 38 cm) pan
Related wikiHows
References
-
↑ https://www.epicurious.com/recipes/food/views/middle-eastern-nut-filled-multilayered-pastry-baklava-103991 -
↑ https://www.tasteofhome.com/recipes/baklava-with-honey-syrup/ -
↑ https://www.epicurious.com/recipes/food/views/middle-eastern-nut-filled-multilayered-pastry-baklava-103991 -
↑ https://www.epicurious.com/recipes/food/views/middle-eastern-nut-filled-multilayered-pastry-baklava-103991 -
↑ https://www.epicurious.com/recipes/food/views/middle-eastern-nut-filled-multilayered-pastry-baklava-103991 -
↑ https://food52.com/recipes/24860-citrus-and-cardamom-baklava-with-pistachios-and-walnuts -
↑ https://www.finecooking.com/recipe/classic-baklava -
↑ https://www.epicurious.com/recipes/food/views/middle-eastern-nut-filled-multilayered-pastry-baklava-103991 -
↑ https://www.epicurious.com/recipes/food/views/middle-eastern-nut-filled-multilayered-pastry-baklava-103991 -
↑ https://www.epicurious.com/recipes/food/views/middle-eastern-nut-filled-multilayered-pastry-baklava-103991 -
↑ https://www.epicurious.com/recipes/food/views/middle-eastern-nut-filled-multilayered-pastry-baklava-103991 -
↑ https://www.epicurious.com/recipes/food/views/middle-eastern-nut-filled-multilayered-pastry-baklava-103991 -
↑ https://www.epicurious.com/recipes/food/views/middle-eastern-nut-filled-multilayered-pastry-baklava-103991 -
↑ https://www.epicurious.com/recipes/food/views/middle-eastern-nut-filled-multilayered-pastry-baklava-103991 -
↑ https://www.epicurious.com/recipes/food/views/middle-eastern-nut-filled-multilayered-pastry-baklava-103991 -
↑ https://www.epicurious.com/recipes/food/views/middle-eastern-nut-filled-multilayered-pastry-baklava-103991 -
↑ https://www.finecooking.com/recipe/classic-baklava -
↑ https://www.finecooking.com/recipe/classic-baklava -
↑ https://www.cooksinfo.com/phyllo-pastry


In order to connect Teleporter to your Oracle database, you need to download the Oracle Database JDBC Driver.
By downloading this driver, you must accept the OTN License Agreement terms.
For more info about the OTN License Agreement please visit the link
http://www.oracle.com/technetwork/licenses/distribution-license-152002.html


(load "aima.lisp") (aima-load 'all) (aima-compile) (test 'all)The compiler will compile all the files, and the test mechanism will test the resulting code. Look for "0 errors" in the output and a 0 as the return value.
| AIMA Home | Contact Russell & Norvig | What's new | Changed 3/13/97 |


 Enjoy!
Lets Make a Pizza!
Toppings: $.50 each
Pepperoni
Sausage
Chicken
Mushrooms
Green Peppers
Olives
Mushrooms
Artichokes
Anchovies
Fresh Garlic
Pick a size
Small
Medium
Large
Extra-Large
Total
Add Another Pizza


All
H-Bond
Clash
VDW
Default
Color Type
from...
to...
with
without minimization
Ligands:
Click and drag the selected ligand to move it. Alt+drag rotates it.
PDB ID


|
Page Not Found
We're sorry - the page or function you tried to access could not be found on our web site. Would you take a moment to email us at<EMAIL_ADDRESS>Please include details of how you arrived at this page so that we can correct the problem.
Thank you for your help,
Stand to Reason
|


The baiscs of the WEB are broken into 5 categories; WEB, HTML, URLS, HTTP, and WEB Applications. WEB interaction involves computers, HTTP requests, servers, HTML documents, and web browsers. The WWW is a collection of HTML documents, HTML stands for Hypertext Markup Language, it glues everything together and is the heart of the WEB. Hyperlinks link the HTML documents together, makign the WEB, web like. The Internet was invented in 1990, it has over 30 billion pages. This video gives a good overview.
HTML, TAGS, & ELEMENTSHTML documents contain text content which describes "what you see", markup which describes "how it looks", reference to other documents images and videos, and links to other pages. HTML uses tags to tell browsers what type of HTML element to use. This video gives a good overview. HTTP Elements include the opening tag, content, and closing tag. Tags that have content require a closing tag, if the tag does not have content it is known as void and does not require a closing tag.
White Space, Inline, BlockThe size of white space always equals one, no matter how large or long the white space appears in HTML. Two Tags that help break out or group the HTML content are line break and paragrah. In addiiton HTML Elements are either inline or block. Block elements form an "invisible box" around the content inside of them. Break is inline and paragrah is block. This video explains the distinction well.
Main Take Away Topics


In this section you can download publications such as factsheets, brochures, posters and more. Please share them with community institutions such as schools, organizations and businesses. Make them available to local or national media and government offices. Feel free to translate them into your official language as well. If you wish to contribute to this section please contact us.
Learn more about why biodiversity is important and how it is endangered. Help spread the word about living in harmony with nature!


MIN12XXW(1) MIN12XXW(1) NAME min12xxw - Convert pbmraw streams to Minolta PagePro 12xxW languages SYNOPSIS min12xxw [options] DESCRIPTION Min12xxw is a filter which converts pbmraw streams (produced by ghost‐ script, for example) to the printer language of Minolta PagePro 1[234]xxW printers. COMMAND-LINE OPTIONS -h, --help Gives usage information (help) -v, --version Displays the version number and exit -e, --ecomode Enables economic mode which saves toner by leaving every other scan‐ line blank. This degrades the printout's resolution a little, the effect is most easily seen (and looks particularly bad) when print‐ ing in 300 dpi mode. -s, --status Query the printer status, page counter and whatever information can be retrieved. The printer status is basically an unprocessed dump of what the printer sends, so unexpected things may happen if the printer sends funny data because it got confused somehow... This might however still be useful. The page counter and other informa‐ tion is heavily processed and should be more reliable. Note that for queries to be made, the printer must (of course) be switched on, with all cables connected, and not be busy printing (or your print job may be truncated). See the -d option below which sets the device file to use. This has so far only been tested on 1200W, 1350W and 1400W printers. Send mail if it works for others as well. -d dev, --device dev Sets the device file to use for queries. The default is /dev/lp0. Please note that this option is only meaningful with the "-s" or "--status" option. If you intend to send a document to the printer, you have to redirect min12xxw's standard output to the device file in question. See the documentation that came with your shell on how to do that. -n, --nomargins Disables the enforcement of the 0.17 inch margins on all sides of the paper. The converter discards the equivalent of this length of its input because ghostscript outputs a full page with margins. If you arranged in some way for the input to be marginless, or have slightly larger paper, you can give this option to include the full input with margins. Please note that for very small page dimensions, min12xxw might need to disable enforcing the page margins for all pages following the offending page to make the job printable. In that case, a warning message will be printed on the standard error stream to inform the user. -m model, --model model Sets which printer model to produce output for. Currently, no checks for features only available to specific models are made (available paper trays differ from model to model, for example). Let me know if this causes problems. Available models are: 1200W, 1250W, 1300W, 1350W, 1400W. 1200W is the default. As an alternative, you can also symlink, link or rename your executable to min1200w, min1250w, min1300w, min1350w or min1400w, thus making the model specified in the filename the default model. This saves you from typing the model selection option again and again and again... Please note that you must supply the model option correctly if you drive any other model than what is the default. If you fail to do so, your printer will not produce any output or react to status queries from the host. -r resolution, --res resolution Sets the resolution to either 300, 600 or 1200 dpi (600 dpi is the default). Keep in mind that you need to produce your output accord‐ ingly. It is also possible to specify the resolution as (horizon‐ tal)x(vertical) resolution (e.g. -r 1200x600) where horizontal reso‐ lution may be once or twice the vertical resolution. The maximum resolution is 1200 dpi in both vertical and horizontal direction. The minimum vertical resolution for mixed resolution printing seems to be 600 dpi. 300 dpi printing has only been tested on 1200W, 1350W and 1400W models. Mixed resolution printing was seen for 13xxW and 1400W models only, but tests show that the 1200W is capable of han‐ dling it as well, so chances are that 1250W printers won't have trouble, either. -t tray, --tray tray Sets the paper tray to be used. Valid values for tray are "auto", "tray1", "tray2" and "manual", with "auto" being the default. Not all printer models have all sorts of paper trays. "auto" should be safe on all of them, I think. In fact, the PagePro 1400W seems to have only this kind of paper tray. -p type, --papertype type Sets the type of paper used. Type can be one of "normal", "thick", "transparency", "envelope" or "postcard". "normal" is the default. -f fmt, --paperformat fmt This sets the paper format to be used for the print job. The default value for fmt is "a4". Valid values are given below. a4 A4 paper (210 mm x 297 mm) b5 B5 envelope (176 mm x 250 mm) a5 A5 paper (148 mm x 210 mm) jpost Post card (100 mm x 148 mm) corpost Correspondence Postcard (148 mm x 200 mm) jisy6 JIS Yokei 6-gou paper (98 mm x 190 mm) jisy0 JIS Yokei 0-gou paper (120 mm x 235 mm) chinese16k Chinese 16K paper (185 mm x 260 mm) chinese32k Chinese 32K paper (130 mm x 185 mm) legal Legal paper (8.5" x 14") glegal G. Legal paper (8.5" x 13") letter Letter paper (8.5" x 11") gletter G. Letter paper (8.5" x 10.5") executive Executive paper (7.25" x 10.5") halfletter Halfletter paper (5.5" x 8.5") envmonarch Envelope Monarch (3.875" x 7.5") env10 Envelope COM-10 (8.125" x 9.5") envdl Envelope DL (110 mm x 220 mm) envc5 Envelope C5 (162 mm x 229 mm) envc6 Envelope C6 (114 mm x 162 mm) envb5 Envelope B5 (176 mm x 250 mm) Choukei-3Gou Choukei-3Gou paper (120mm x 235 mm) Choukei-4Gou Choukei-4Gou paper (90 mm x 205 mm) custom Custom paper size envb6 Envelope 6 3/4 (3.625" x 6.5") folio F4/Folio paper (210 mm x 330 mm) jisy1 JIS Yokei 1-gou (120 mm x 176 mm) jisy2 JIS Yokei 2-gou (105 mm x 235 mm) quadpost Quad postcard (200 mm x 296 mm) EXAMPLES gs -q -dBATCH -dSAFER -dQUIET -dNOPAUSE -sPAPERSIZE=a4 -r1200 -sDE‐ VICE=pbmraw -sOutputFile=- - < test.ps | min12xxw -r 1200 > test.min This would convert a postscript file test.ps to a file test.min which could be sent directly to the printer, a 1200W to be exact. The output is rendered at 1200 dpi. If you have to drive some other model, see the model selection option (-m) above. PORTABILITY Min12xxw should run on most *nix-like workstations without major prob‐ lems. Library functions which are known to be missing on non-Linux sys‐ tems such as getline or getopt_long may have to be replaced by an appro‐ priate substitute. In case of getline and getopt_long this has already been done. The query options may or may not work on other systems, depending on the characteristics of the printer driver and the interface used (USB, very old style parallel port or a more recent one...). BUGS/LIMITATIONS/CONTRIBUTORS Min12xxw was written without any documentation from the manufacturer. The description of the printer language may be inaccurate or even wrong because it was obtained by looking at the output of the windoof driver only. The code dealing with the compression of raster data is in its spirit heavily based on an initial driver by Adam Bocim <beetman@sez‐ nam.cz> who managed to find out how things are done (thanks, Adam, you did a great job!). This new version is considerably faster, implemented more cleanly and (hopefully) well documented. It also features querying the printer status and page counter, a sugges‐ tion made by Bruno Schoedlbauer<EMAIL_ADDRESS>who also pointed me to a nice USB sniffer by Benoit Papillault for Windoof 98 and up, see http://benoit.papillault.free.fr/usbsnoop. (That little program may prove very helpful on similar occasions. Happy USB sniffing...) David Hamilton<EMAIL_ADDRESS>has helped a lot in testing and developing the support for the PagePro 1350W. Even though this program has been designed with care and much thought, no-one can guarantee that this program will not damage your printer, com‐ puter or even your neighbour's car, because it was built without knowing exactly how things work, it's only a (hopefully) reasonable guess. (How‐ ever, my printer does still work, even after the testing phase when a lot of wrong stuff was sent to it. And my neighbour hasn't complained either...) Most of the available paper sizes have not actually been verified to work as advertised - reports about successes or problems are welcome. Also the code for querying the printer is not heavily tested. If you have com‐ ments to make or know more about the format than I do, please share your thoughts and your knowledge. 13xxW series support seems to be relatively well tested by now. Send mail with feedback if you have such a printer and you experience problems. 1400W support is pretty new - please send e-mail if it works or if you run into problems. Feedback on models for which support has just been completed is very important to improve and stabilise this support. Bugs and problems reports are generally welcome because I just don't have the time to test everything out. I needed a filter and here it is. If it does not work - complain ;-) AUTHOR Min12xxw was written by Manuel Tobias Schiller (mala@hinterbergen.de). Local Utilities December 2005 MIN12XXW(1)


These are examples of different ways to use the Naked CSS Grid. Since Naked is mobile-first, we'll stack content by default. You do have access to an entirely separate small grid to use up to the 768px breakpoint. This means you can create some pretty complex layouts and even drop columns if you want.

Web Design

Web Development

Illustrations

Designer


Janrain API-Based Registration
User
Sign Out
Sign In
Create Account
×
Close
Sign In
With your existing acount from...
With a traditional account...
Email address
Email address
Sign In
×
Close
Almost Done!
Hello